Ticket #99: libsyncml-auth-chal.diff

File libsyncml-auth-chal.diff, 7.6 kB (added by dgollub, 2 years ago)

Initial patch to handle the <Chal> node.

  • libsyncml/sml_elements_internals.h

    old new  
    7676        char *data; 
    7777}; 
    7878 
     79struct SmlChal { 
     80        SmlFormatType format; 
     81        SmlAuthType type; 
     82        char *nonce; 
     83}; 
     84 
    7985#endif //_SML_ELEMENTS_INTERNALS_H_ 

  • libsyncml/sml_command_internals.h

    old new  
    9292        SmlLocation *sourceRef; 
    9393        SmlLocation *targetRef; 
    9494        SmlCred *cred; 
     95        SmlChal *chal; 
    9596        SmlItem *item; 
    9697         
    9798        SmlCommand *result; 

  • libsyncml/sml_elements.c

    old new  
    528528        smlTrace(TRACE_EXIT, "%s", __func__); 
    529529} 
    530530 
     531void smlChalFree(SmlChal *chal) 
     532{ 
     533        smlTrace(TRACE_ENTRY, "%s(%p)", __func__, chal); 
     534        smlAssert(chal); 
     535         
     536        if (chal->nonce) 
     537                g_free(chal->nonce); 
     538         
     539        g_free(chal); 
     540         
     541        smlTrace(TRACE_EXIT, "%s", __func__); 
     542} 
     543 
    531544SmlMapItem *smlMapItemNew(const char *uid, const char *newuid, SmlError **error) 
    532545{ 
    533546        smlTrace(TRACE_ENTRY, "%s(%s, %s, %p)", __func__, uid, newuid, error); 

  • libsyncml/sml_elements.h

    old new  
    5454void smlHeaderFree(SmlHeader *header); 
    5555 
    5656void smlCredFree(SmlCred *cred); 
     57void smlChalFree(SmlChal *chal); 
    5758 
    5859SmlMapItem *smlMapItemNew(const char *uid, const char *newuid, SmlError **error); 
    5960void smlMapItemRef(SmlMapItem *item); 

  • libsyncml/syncml.h

    old new  
    6060typedef struct SmlSanAlert SmlSanAlert; 
    6161typedef struct SmlMapItem SmlMapItem; 
    6262typedef struct SmlCred SmlCred; 
     63typedef struct SmlChal SmlChal; 
    6364typedef struct SmlHeader SmlHeader; 
    6465typedef struct SmlTransportData SmlTransportData; 
    6566typedef struct SmlObject SmlObject; 

  • libsyncml/parser/sml_xml_parse.c

    old new  
    462462        return FALSE; 
    463463} 
    464464 
     465static SmlBool _smlChalMetaParse(SmlXmlParser *parser, char **format, char **type, char **nonce, SmlError **error) 
     466{ 
     467        smlTrace(TRACE_ENTRY, "%s(%p, %p, %p, %p, %p, %p, %p)", __func__, parser, format, type, nonce, error); 
     468        smlAssert(parser); 
     469         
     470        while (1) { 
     471                if (!_smlXmlParserStep(parser)) { 
     472                        smlErrorSet(error, SML_ERROR_GENERIC, "Missing nodes"); 
     473                        goto error; 
     474                } 
     475 
     476                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META) && \ 
     477                xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) { 
     478                        break; 
     479                } else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) { 
     480                        smlErrorSet(error, SML_ERROR_GENERIC, "Not a start node"); 
     481                        goto error; 
     482                } 
     483                 
     484                if (type && !strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TYPE)) { 
     485                        if (!_smlXmlParserGetString(parser, type, SML_ELEMENT_TYPE, error)) 
     486                                goto error; 
     487                } else if (format && !strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_FORMAT)) { 
     488                        if (!_smlXmlParserGetString(parser, format, SML_ELEMENT_FORMAT, error)) 
     489                                goto error; 
     490                } else if (format && !strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_NEXTNONCE)) { 
     491                        if (!_smlXmlParserGetString(parser, nonce, SML_ELEMENT_NEXTNONCE, error)) 
     492                                goto error; 
     493                } else { 
     494                        smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node: %s", xmlTextReaderConstName(parser->reader)); 
     495                        goto error; 
     496                } 
     497        } 
     498         
     499        smlTrace(TRACE_EXIT, "%s", __func__); 
     500        return TRUE; 
     501 
     502error: 
     503        if (format) 
     504                *format = NULL; 
     505        if (nonce) 
     506                *nonce = NULL; 
     507        if (type) 
     508                *type = NULL; 
     509 
     510        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
     511        return FALSE; 
     512} 
     513 
    465514static SmlBool _smlCommandMetaParse(SmlXmlParser *parser, char **format, char **type, SmlAnchor **anchor, unsigned int *size, int *maxobjsize, SmlError **error) 
    466515{ 
    467516        smlTrace(TRACE_ENTRY, "%s(%p, %p, %p, %p, %p, %p, %p)", __func__, parser, format, type, anchor, size, maxobjsize, error); 
    …… 
    760809        return NULL; 
    761810} 
    762811 
     812static SmlChal *_smlChalParse(SmlXmlParser *parser, SmlError **error) 
     813{ 
     814        smlTrace(TRACE_ENTRY, "%s(%p, %p)", __func__, parser, error); 
     815        smlAssert(parser); 
     816        char *format = NULL; 
     817        char *type = NULL; 
     818         
     819        SmlChal *chal = smlTryMalloc0(sizeof(SmlChal), error); 
     820        if (!chal) 
     821                goto error; 
     822         
     823        while (1) { 
     824                if (!_smlXmlParserStep(parser)) { 
     825                        smlErrorSet(error, SML_ERROR_GENERIC, "Missing nodes"); 
     826                        goto error_free_chal; 
     827                } 
     828                 
     829                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CHAL) && \ 
     830                xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) { 
     831                        break; 
     832                } else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) { 
     833                        smlErrorSet(error, SML_ERROR_GENERIC, "Not a start node"); 
     834                        goto error_free_chal; 
     835                } 
     836                 
     837                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META)) { 
     838                        if (!_smlChalMetaParse(parser, &format, &type, &chal->nonce, error)) 
     839                                goto error_free_chal; 
     840                } else { 
     841                        smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node %s", xmlTextReaderConstName(parser->reader)); 
     842                        goto error_free_chal; 
     843                } 
     844        } 
     845                 
     846        if (!format || !strcmp(format, SML_BASE64)) { 
     847                chal->format = SML_FORMAT_TYPE_BASE64; 
     848        } else { 
     849                smlErrorSet(error, SML_ERROR_GENERIC, "Unknown format"); 
     850                goto error_free_chal; 
     851        } 
     852         
     853        if (!type || !strcmp(type, SML_AUTH_BASIC)) { 
     854                chal->type = SML_AUTH_TYPE_BASIC; 
     855        } else if (!strcmp(type, SML_AUTH_MD5)) { 
     856                chal->type = SML_AUTH_TYPE_MD5; 
     857        } else { 
     858                smlErrorSet(error, SML_ERROR_GENERIC, "Unknown type"); 
     859                goto error_free_chal; 
     860        } 
     861         
     862        if (format) 
     863                g_free(format); 
     864        if (type) 
     865                g_free(type); 
     866         
     867        smlTrace(TRACE_EXIT, "%s: %p", __func__, chal); 
     868        return chal; 
     869 
     870error_free_chal: 
     871        smlChalFree(chal); 
     872error: 
     873        if (format) 
     874                g_free(format); 
     875        if (type) 
     876                g_free(type); 
     877        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
     878        return NULL; 
     879} 
     880 
    763881static SmlBool _smlChangeParse(SmlXmlParser *parser, SmlCommand **cmd, SmlCommandType type, const char *name, SmlError **error) 
    764882{ 
    765883        smlTrace(TRACE_ENTRY, "%s(%p, %i, %s, %p)", __func__, parser, type, name, error); 
    …… 
    16141732         
    16151733        char *locURI = NULL; 
    16161734        SmlItem *item = NULL; 
     1735        SmlChal *chal = NULL; 
    16171736         
    16181737        /* Lets check if the next node is a command node */ 
    16191738        if (smlCommandTypeFromString((char *)xmlTextReaderConstName(parser->reader), NULL) != SML_COMMAND_TYPE_UNKNOWN && xmlTextReaderNodeType(parser->reader) == XML_NODE_START) { 
    …… 
    17041823                        item = _smlItemParse(parser, NULL, SML_COMMAND_TYPE_ALERT, error); 
    17051824                        if (!item) 
    17061825                                goto error_free_status; 
     1826                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CHAL)) { 
     1827                        chal = _smlChalParse(parser, error); 
     1828                        if (!chal) 
     1829                                goto error_free_status; 
    17071830                } else { 
    17081831                        smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node"); 
    17091832                        goto error; 

  • libsyncml/sml_defines.h

    old new  
    6969#define SML_ELEMENT_MEM "Mem" 
    7070#define SML_ELEMENT_FREEID "FreeID" 
    7171#define SML_ELEMENT_VERSION "Version" 
     72#define SML_ELEMENT_NEXTNONCE "NextNonce" 
    7273 
    7374/* For devinf */ 
    7475#define SML_ELEMENT_CTCAP "CTCap"