root/lang/c/NetworkUpdater/trunk/Build/Common.c @ 38243

#ifndef NUI_DISTRIBUTION
#  include "Common.h"
#endif

int NUI_IsBadReadWritePointer(void* pointer, size_t bytes) {
    return NUI_IsBadReadPointer(pointer, bytes) || NUI_IsBadWritePointer(pointer, bytes);
}

char* NUI_strdup(const char* s) {
    size_t bytes = 0;
    char* buf = NULL;
    bytes = strlen(s) + 1;
    buf = (char*)calloc(bytes, 1);
    if (!buf) {
        return NULL;
    }
    memcpy(buf, s, bytes);
    return buf;
}

NU_Error NUI_Search(NUI_ThreadData* object) {
    NU_Error error = NU_NO_ERROR;

    if (!object->update_information) {
        error = NUI_CreateDownloadContext(
            &object->update_information,
            object->releases_file_url,
            object->releases_file_path);
        if (error) {
            goto clean_up;
        }
    }

    if (!object->update_information->complete) {
        error = NUI_Download(object->update_information);
        NUI_Lock(object->common.shared);
        object->common.shared->user.list.total = object->update_information->total;
        object->common.shared->user.list.downloaded = object->update_information->downloaded;
        NUI_Unlock(object->common.shared);
        object->pending = object->update_information->pending;
        if (error || object->pending) {
            goto clean_up;
        }
    }

    error = NUI_ReadReleasesFile(object);
clean_up:
    if (!object->pending && object->update_information) {
                NUI_DestroyDownloadContext(object->update_information);
        object->update_information = NULL;
        }

    return error;
}

NU_Error NUI_NetworkUpdaterToInternal(NUI_NetworkUpdater** internal_object_output, NU_NetworkUpdater* object) {
    NU_Error error = NU_NO_ERROR;
    NUI_NetworkUpdater* internal_object = NULL;

    *internal_object_output = 0;

    internal_object = (NUI_NetworkUpdater*)object->internal_data;

    if (NUI_IsBadReadWritePointer(internal_object, sizeof(internal_object))) {
        error = NU_ERROR_INVALID_UPDATER;
        goto clean_up;
    }

        internal_object->user = (NU_NetworkUpdater*)object;

        *internal_object_output = internal_object;

clean_up:
    return error;
}

NU_Error NUI_GetStatus(NUI_NetworkUpdater* object) {
    NU_Error error = NU_NO_ERROR;
    NUI_Lock(object->common.shared);
    *object->user = object->common.shared->user;
    error = object->common.shared->user.error;
    NUI_Unlock(object->common.shared);
    return error;
}

/* -----------------------------------------------------------------------
 * Interfaces
 * ----------------------------------------------------------------------- */

#define NUI_API_PRECONDITION                                            \
    NUI_NetworkUpdater* internal_context = NULL;                        \
    object->error = NUI_NetworkUpdaterToInternal(&internal_context, object); \
    if (object->error) {                                                \
        return 0;                                                       \
    }

int NU_Create(NU_NetworkUpdater* object, const NU_Option* option) {
    if (NUI_IsBadReadWritePointer(object, sizeof(*object))) {
        return 0;
    }

    memset(object, 0, sizeof(*object));

    object->internal_data = calloc(sizeof(NUI_NetworkUpdater), 1);
    if (!object->internal_data) {
        object->error = NU_ERROR_BAD_ALLOC;
        return 0;
    }
    
    {
        NUI_API_PRECONDITION;
        object->error = NUI_Create(internal_context, option);
        return !object->error;
    }
}

int NU_Destroy(NU_NetworkUpdater* object) {
    NUI_API_PRECONDITION;
    object->error = NUI_Destroy(internal_context);
    return !object->error;
}

int NU_GetStatus(NU_NetworkUpdater* object) {
    NUI_API_PRECONDITION;
    object->error = NUI_GetStatus(internal_context);
    return !object->error;
}

int NU_StartSearch(NU_NetworkUpdater* object) {
    NUI_API_PRECONDITION;
    object->error = NUI_StartSearch(internal_context);
    return !object->error;
}

int NU_StartUpdate(NU_NetworkUpdater* object) {
    NUI_API_PRECONDITION;
    object->error = NUI_StartUpdate(internal_context);
    return !object->error;
}

int NU_Cancel(NU_NetworkUpdater* object) {
    NUI_API_PRECONDITION;
    object->error = NUI_Cancel(internal_context);
    return !object->error;
}

void InternalTest(void) {
    NU_Error error = NU_NO_ERROR;
    NUI_DownloadContext* object;

    error = NUI_CreateDownloadContext(
        &object, 
        _T("http://upload.wikimedia.org/wikipedia/commons/b/bd/Rondo_Alla_Turka.ogg"),
        _T("C:\\temp\\bbb.ogg"));

    if (error) {
        abort();
    }

    do {
        error = NUI_Download(object);
    } while (object->pending);

    NUI_DestroyDownloadContext(object);
}