Beispiel #1
0
static int prv_fill_item(SmlItemPtr_t itemP,
                         dmtree_node_t node)
{
    itemP->source = smlAllocSource();
    if (!itemP->source)
    {
        return OMADM_SYNCML_ERROR_COMMAND_FAILED;
    }
    smlFreePcdata(itemP->source->locURI);
    itemP->source->locURI = smlString2Pcdata(node.uri);
    if (node.data_buffer)
    {
        itemP->data = smlAllocPcdata();
        if (!itemP->data)
        {
            return OMADM_SYNCML_ERROR_COMMAND_FAILED;
        }
        itemP->data->content = malloc(node.data_size);
        if (!itemP->data->content)
        {
            return OMADM_SYNCML_ERROR_COMMAND_FAILED;
        }
        memcpy(itemP->data->content, node.data_buffer, node.data_size);
        itemP->data->contentType = SML_PCDATA_OPAQUE;
        itemP->data->length = node.data_size;
    }
    itemP->meta = convert_to_meta(node.format, node.type);

    return OMADM_SYNCML_ERROR_SUCCESS;
}
Beispiel #2
0
SmlCredPtr_t get_credentials(authDesc_t * authP)
{
    SmlCredPtr_t credP = NULL;

    switch (authP->type)
    {
    case AUTH_TYPE_BASIC:
        {
            char * digest;

            digest = prv_get_digest_basic(authP);
            if (digest == NULL) goto error;

            credP = smlAllocCred();
            if (credP)
            {
                credP->meta = convert_to_meta("b64", META_TYPE_BASIC);
                set_pcdata_string(credP->data, digest);
            }
            free(digest);
        }
        break;
    case AUTH_TYPE_DIGEST:
        {
            char * digest;

            digest = prv_get_digest_md5(authP);
            if (digest == NULL) goto error;

            credP = smlAllocCred();
            if (credP)
            {
                credP->meta = convert_to_meta("b64", META_TYPE_DIGEST);
                set_pcdata_string(credP->data, digest);
            }
            free(digest);
        }
        break;

    default:
        // Authentification is either done at another level or not supported
        break;
    }

error:
    return credP;
}
dmclt_err_t omadmclient_add_generic_alert(dmclt_session sessionH,
										  char * correlator,
                                          dmclt_item_t * itemP)
{
    internals_t * internP = (internals_t *)sessionH;
    SmlAlertPtr_t alertP;
    
    if (!internP || !itemP || !itemP->type || !itemP->format || !itemP->data)
    {
        return DMCLT_ERR_USAGE;
    }

    alertP = smlAllocAlert();
    if (NULL == alertP)
    {
        return DMCLT_ERR_MEMORY;
    }
    
    alertP->data = smlString2Pcdata("1226");
    if (NULL == alertP->data)
    {
        smlFreeAlert(alertP);
        return DMCLT_ERR_MEMORY;
    }

    if (correlator)
    {
        alertP->correlator = smlString2Pcdata(correlator);
        if (NULL == alertP->correlator)
        {
            smlFreeAlert(alertP);
            return DMCLT_ERR_MEMORY;
        }
    }

    if (itemP->source)
    {
        alertP->itemList->item->source = smlAllocSource();
        if (NULL == alertP->itemList->item->source)
        {
            smlFreeAlert(alertP);
            return DMCLT_ERR_MEMORY;
        }
        alertP->itemList->item->source->locURI = smlString2Pcdata(itemP->source);
    }
    
    if (itemP->target)
    {
        alertP->itemList->item->target = smlAllocTarget();
        if (NULL == alertP->itemList->item->target)
        {
            smlFreeAlert(alertP);
            return DMCLT_ERR_MEMORY;
        }
        alertP->itemList->item->target->locURI = smlString2Pcdata(itemP->target);
    }

    alertP->itemList->item->meta = convert_to_meta(itemP->format, itemP->type);
    alertP->itemList->item->data = smlString2Pcdata(itemP->data);
    if (NULL == alertP->itemList->item->meta || NULL == alertP->itemList->item->data)
    {
        smlFreeAlert(alertP);
        return DMCLT_ERR_MEMORY;
    }

    add_element(internP, (basicElement_t *)alertP);

    return DMCLT_ERR_NONE;
}