Return to testupnpreplyparse.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / miniupnpd / miniupnpc / src

Annotation of embedaddon/miniupnpd/miniupnpc/src/testupnpreplyparse.c, revision 1.1.1.1

1.1       misho       1: /* $Id: testupnpreplyparse.c,v 1.4 2014/01/27 11:45:19 nanard Exp $ */
                      2: /* MiniUPnP project
                      3:  * http://miniupnp.free.fr/ or http://miniupnp.tuxfamily.org/
                      4:  * (c) 2006-2017 Thomas Bernard
                      5:  * This software is subject to the conditions detailed
                      6:  * in the LICENCE file provided within the distribution */
                      7: #include <stdio.h>
                      8: #include <string.h>
                      9: #include <stdlib.h>
                     10: #include "upnpreplyparse.h"
                     11: 
                     12: int
                     13: test_parsing(const char * buf, int len, FILE * f)
                     14: {
                     15:        char line[1024];
                     16:        struct NameValueParserData pdata;
                     17:        int ok = 1;
                     18:        ParseNameValue(buf, len, &pdata);
                     19:        /* check result */
                     20:        if(f != NULL)
                     21:        {
                     22:                while(fgets(line, sizeof(line), f))
                     23:                {
                     24:                        char * value;
                     25:                        char * equal;
                     26:                        char * parsedvalue;
                     27:                        int l;
                     28:                        l = strlen(line);
                     29:                        while((l > 0) && ((line[l-1] == '\r') || (line[l-1] == '\n')))
                     30:                                line[--l] = '\0';
                     31:                        /* skip empty lines */
                     32:                        if(l == 0)
                     33:                                continue;
                     34:                        equal = strchr(line, '=');
                     35:                        if(equal == NULL)
                     36:                        {
                     37:                                fprintf(stderr, "Warning, line does not contain '=' : %s\n", line);
                     38:                                continue;
                     39:                        }
                     40:                        *equal = '\0';
                     41:                        value = equal + 1;
                     42:                        parsedvalue = GetValueFromNameValueList(&pdata, line);
                     43:                        if((parsedvalue == NULL) || (strcmp(parsedvalue, value) != 0))
                     44:                        {
                     45:                                fprintf(stderr, "Element <%s> : expecting value '%s', got '%s'\n",
                     46:                                        line, value, parsedvalue ? parsedvalue : "<null string>");
                     47:                                ok = 0;
                     48:                        }
                     49:                }
                     50:        }
                     51:        ClearNameValueList(&pdata);
                     52:        return ok;
                     53: }
                     54: 
                     55: int main(int argc, char * * argv)
                     56: {
                     57:        FILE * f;
                     58:        char * buffer;
                     59:        long l;
                     60:        int ok;
                     61: 
                     62:        if(argc<2)
                     63:        {
                     64:                fprintf(stderr, "Usage: %s file.xml [file.namevalues]\n", argv[0]);
                     65:                return 1;
                     66:        }
                     67:        f = fopen(argv[1], "r");
                     68:        if(!f)
                     69:        {
                     70:                fprintf(stderr, "Error : can not open file %s\n", argv[1]);
                     71:                return 2;
                     72:        }
                     73:        if(fseek(f, 0, SEEK_END) < 0) {
                     74:                perror("fseek");
                     75:                return 1;
                     76:        }
                     77:        l = (int)ftell(f);
                     78:        if(l < 0) {
                     79:                perror("ftell");
                     80:                return 1;
                     81:        }
                     82:        if(fseek(f, 0, SEEK_SET) < 0) {
                     83:                perror("fseek");
                     84:                return 1;
                     85:        }
                     86:        buffer = malloc(l + 1);
                     87:        if(buffer == NULL) {
                     88:                fprintf(stderr, "Error: failed to allocate %ld bytes\n", l+1);
                     89:                return 1;
                     90:        }
                     91:        l = fread(buffer, 1, l, f);
                     92:        fclose(f);
                     93:        f = NULL;
                     94:        buffer[l] = '\0';
                     95:        if(argc > 2)
                     96:        {
                     97:                f = fopen(argv[2], "r");
                     98:                if(!f)
                     99:                {
                    100:                        fprintf(stderr, "Error : can not open file %s\n", argv[2]);
                    101:                        return 2;
                    102:                }
                    103:        }
                    104: #ifdef DEBUG
                    105:        DisplayNameValueList(buffer, l);
                    106: #endif
                    107:        ok = test_parsing(buffer, l, f);
                    108:        if(f)
                    109:        {
                    110:                fclose(f);
                    111:        }
                    112:        free(buffer);
                    113:        return ok ? 0 : 3;
                    114: }
                    115: