Ignore:
Timestamp:
01/15/11 20:14:37 (10 years ago)
Author:
Admin
Message:

WebIf: Internal change: Add support for one-time-use templates. Make addmode-variable selfdocumenting.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/oscam-http-helpers.c

    r4437 r4480  
    66/* Adds a name->value-mapping or appends to it. You will get a reference back which you may freely
    77   use (but you should not call free/realloc on this!)*/
    8 char *tpl_addVar(struct templatevars *vars, int append, char *name, char *value){   
     8char *tpl_addVar(struct templatevars *vars, uint8 addmode, char *name, char *value){   
    99    if(name == NULL || value == NULL) return "";
    1010    int i;
     
    1818    if(result == NULL){
    1919        if((*vars).varsalloc <= (*vars).varscnt){
    20             if(!cs_realloc(&(*vars).names, (*vars).varsalloc * 2 * sizeof(char**), -1)) return value;
    21             if(!cs_realloc(&(*vars).values, (*vars).varsalloc * 2 * sizeof(char**), -1)) return value;
     20            if(!cs_realloc(&(*vars).names, (*vars).varsalloc * 2 * sizeof(char**), -1)) return "";
     21            if(!cs_realloc(&(*vars).values, (*vars).varsalloc * 2 * sizeof(char**), -1)) return "";
     22            if(!cs_realloc(&(*vars).vartypes, (*vars).varsalloc * 2 * sizeof(uint8*), -1)) return "";
    2223            (*vars).varsalloc = (*vars).varscnt * 2;
    2324        }
    24         if(!cs_malloc(&tmp,(strlen(name) + 1) * sizeof(char), -1)) return value;
    25         strcpy(tmp, name);
     25        int len = strlen(name) + 1;
     26        if(!cs_malloc(&tmp, len * sizeof(char), -1)) return "";
     27        memcpy(tmp, name, len);
    2628        (*vars).names[(*vars).varscnt] = tmp;
    27         if(!cs_malloc(&tmp,(strlen(value) + 1) * sizeof(char), -1)){
     29       
     30        len = strlen(value) + 1;
     31        if(!cs_malloc(&tmp, len * sizeof(char), -1)){
    2832            free((*vars).names[(*vars).varscnt]);
    29             return value;
    30         }
    31         strcpy(tmp, value);
     33            return "";
     34        }
     35        memcpy(tmp, value, len);
    3236        (*vars).values[(*vars).varscnt] = tmp;
    33         (*vars).varscnt = (*vars).varscnt + 1;
     37        (*vars).vartypes[(*vars).varscnt] = addmode;
     38        (*vars).varscnt++;
    3439    } else {
    35         int newlen = strlen(value);
    36         if(append == 1){
    37             int oldlen = strlen((*vars).values[i]);
    38             if(!cs_malloc(&tmp, (oldlen + newlen + 1) * sizeof(char), -1)) return value;
    39             memcpy(tmp, (*vars).values[i], oldlen);
    40             strcpy(tmp + oldlen, value);
    41         } else {
    42             if(!cs_malloc(&tmp, (newlen + 1) * sizeof(char), -1)) return value;
    43             strcpy(tmp, value);
    44         }
    45         free((*vars).values[i]);
    46         (*vars).values[i] = tmp;
     40        int oldlen = 0, newlen = strlen(value);
     41        if(addmode == TPLAPPEND) oldlen = strlen((*vars).values[i]);
     42        if(!cs_realloc(&((*vars).values[i]), (oldlen + newlen + 1) * sizeof(char), -1)) return value;
     43        memcpy((*vars).values[i] + oldlen, value, newlen + 1);
     44        (*vars).vartypes[i] = addmode;
    4745    }
    4846    return tmp;
     
    6765   In either case you will always get a reference back which you may freely use (but you should not call
    6866   free/realloc on this as it will be automatically cleaned!)*/
    69 char *tpl_printf(struct templatevars *vars, int append, char *varname, char *fmtstring, ...){
     67char *tpl_printf(struct templatevars *vars, uint8 addmode, char *varname, char *fmtstring, ...){
    7068    unsigned int needed;
    7169    char test[1];
     
    8482    if(varname == NULL) tpl_addTmp(vars, result);
    8583    else {
    86         char *tmp = tpl_addVar(vars, append, varname, result);
     84        char *tmp = tpl_addVar(vars, addmode, varname, result);
    8785        free(result);
    8886        result = tmp;
     
    102100    }
    103101    if(result == NULL) return "";
    104     else return result;
     102    else {
     103        if((*vars).vartypes[i] == TPLADDONCE){
     104            // This is a one-time-use variable which gets cleaned up automatically after retrieving it
     105            if(!cs_malloc(&(*vars).values[i], 1 * sizeof(char), -1)){
     106                (*vars).values[i] = result;
     107                result[0] = '\0';
     108                return result;
     109            } else {
     110                (*vars).values[i][0] = '\0';
     111                return tpl_addTmp(vars, result);
     112            }
     113        } else return result;
     114    }
    105115}
    106116
     
    123133        return NULL;
    124134    };
     135    if(!cs_malloc(&(*vars).vartypes, (*vars).varsalloc * sizeof(uint8*), -1)){
     136        free((*vars).names);
     137        free((*vars).values);
     138        free(vars);
     139        return NULL;
     140    };
    125141    if(!cs_malloc(&(*vars).tmp, (*vars).tmpalloc * sizeof(char**), -1)){
    126142        free((*vars).names);
    127143        free((*vars).values);
     144        free((*vars).vartypes);
    128145        free(vars);
    129146        return NULL;
Note: See TracChangeset for help on using the changeset viewer.