tools/trace-malloc/formdata.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  *
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is formdata.c code, released
  17  * May 9, 2002.
  18  *
  19  * The Initial Developer of the Original Code is
  20  * Netscape Communications Corporation.
  21  * Portions created by the Initial Developer are Copyright (C) 2002
  22  * the Initial Developer. All Rights Reserved.
  23  *
  24  * Contributor(s):
  25  *   Garrett Arch Blythe, 09-May-2002
  26  *
  27  * Alternatively, the contents of this file may be used under the terms of
  28  * either the GNU General Public License Version 2 or later (the "GPL"), or
  29  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30  * in which case the provisions of the GPL or the LGPL are applicable instead
  31  * of those above. If you wish to allow use of your version of this file only
  32  * under the terms of either the GPL or the LGPL, and not to allow others to
  33  * use your version of this file under the terms of the MPL, indicate your
  34  * decision by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL or the LGPL. If you do not delete
  36  * the provisions above, a recipient may use your version of this file under
  37  * the terms of any one of the MPL, the GPL or the LGPL.
  38  *
  39  * ***** END LICENSE BLOCK ***** */
  40
  41 /*
  42 **  formdata.c
  43 **
  44 **  Play utility to parse up form get data into name value pairs.
  45 */
  46
  47 #include "formdata.h"
  48
  49 #include <stdlib.h>
  50 #include <string.h>
  51 #include <ctype.h>
  52
  53
  54 static void unhexcape(char* inPlace)
  55 /*
  56 **  Real low tech unhexcaper....
  57 **
  58 **  inPlace     string to decode, in place as it were.
  59 */
  60 {
  61     if(NULL != inPlace)
  62     {
  63         int index1 = 0;
  64         int index2 = 0;
  65         int theLen = strlen(inPlace);
  66
  67         for(; index1 <= theLen; index1++)
  68         {
  69             if('%' == inPlace[index1] && '\0' != inPlace[index1 + 1] && '\0' != inPlace[index1 + 2])
  70             {
  71                 int unhex = 0;
  72
  73                 if('9' >= inPlace[index1 + 1])
  74                 {
  75                     unhex |= ((inPlace[index1 + 1] - '0') << 4);
  76                 }
  77                 else
  78                 {
  79                     unhex |= ((toupper(inPlace[index1 + 1]) - 'A' + 10) << 4);
  80                 }
  81
  82                 if('9' >= inPlace[index1 + 2])
  83                 {
  84                     unhex |= (inPlace[index1 + 2] - '0');
  85                 }
  86                 else
  87                 {
  88                     unhex |= (toupper(inPlace[index1 + 2]) - 'A' + 10);
  89                 }
  90
  91                 index1 += 2;
  92                 inPlace[index1] = unhex;
  93             }
  94
  95             inPlace[index2++] = inPlace[index1];
  96         }
  97     }
  98 }
  99
 100
 101 FormData* FormData_Create(const char* inFormData)
 102 {
 103     FormData* retval = NULL;
 104
 105     if(NULL != inFormData)
 106     {
 107         FormData* container = NULL;
 108
 109         /*
 110         **  Allocate form data container.
 111         */
 112         container = (FormData*)calloc(1, sizeof(FormData));
 113         if(NULL != container)
 114         {
 115             /*
 116             **  Dup the incoming form data.
 117             */
 118             container->mStorage = strdup(inFormData);
 119             if(NULL != container->mStorage)
 120             {
 121                 char* traverse = NULL;
 122                 unsigned nvpairs = 1;
 123                 unsigned storeLen = 0;
 124
 125                 /*
 126                 **  Count the number of pairs we are going to have.
 127                 **  We do this by counting '&' + 1.
 128                 */
 129                 for(traverse = container->mStorage; '\0' != *traverse; traverse++)
 130                 {
 131                     if('&' == *traverse)
 132                     {
 133                         nvpairs++;
 134                     }
 135                 }
 136                 storeLen = (unsigned)(traverse - container->mStorage);
 137
 138                 /*
 139                 **  Allocate space for our names and values.
 140                 */
 141                 container->mNArray = (char**)calloc(nvpairs * 2, sizeof(char*));
 142                 if(NULL != container->mNArray)
 143                 {
 144                     char* amp = NULL;
 145                     char* equ = NULL;
 146
 147                     container->mVArray = &container->mNArray[nvpairs];
 148
 149                     /*
 150                     **  Go back over the storage.
 151                     **  Fill in the names and values as we go.
 152                     **  Terminate on dividing '=' and '&' characters.
 153                     **  Increase the count of items as we go.
 154                     */
 155                     for(traverse = container->mStorage; NULL != traverse; container->mNVCount++)
 156                     {
 157                         container->mNArray[container->mNVCount] = traverse;
 158
 159                         amp = strchr(traverse, '&');
 160                         equ = strchr(traverse, '=');
 161                         traverse = NULL;
 162
 163                         if(NULL != equ && (NULL == amp || equ < amp))
 164                         {
 165                             *equ++ = '\0';
 166
 167                             container->mVArray[container->mNVCount] = equ;
 168                         }
 169                         else
 170                         {
 171                             container->mVArray[container->mNVCount] = (container->mStorage + storeLen);
 172                         }
 173
 174                         if(NULL != amp)
 175                         {
 176                             *amp++ = '\0';
 177
 178                             traverse = amp;
 179                         }
 180
 181                         unhexcape(container->mNArray[container->mNVCount]);
 182                         unhexcape(container->mVArray[container->mNVCount]);
 183                     }
 184
 185                     retval = container;
 186                 }
 187             }
 188         }
 189
 190         /*
 191         **  If we failed, cleanup.
 192         */
 193         if(NULL == retval)
 194         {
 195             FormData_Destroy(container);
 196         }
 197     }
 198
 199     return retval;
 200 }
 201
 202
 203 void FormData_Destroy(FormData* inDestroy)
 204 {
 205     if(NULL != inDestroy)
 206     {
 207         unsigned traverse = 0;
 208
 209         for(traverse = 0; traverse < inDestroy->mNVCount; traverse++)
 210         {
 211             if(NULL != inDestroy->mNArray)
 212             {
 213                 inDestroy->mNArray[traverse] = NULL;
 214             }
 215             if(NULL != inDestroy->mVArray)
 216             {
 217                 inDestroy->mVArray[traverse] = NULL;
 218             }
 219         }
 220         inDestroy->mNVCount = 0;
 221
 222         if(NULL != inDestroy->mStorage)
 223         {
 224             free(inDestroy->mStorage);
 225             inDestroy->mStorage = NULL;
 226         }
 227
 228         if(NULL != inDestroy->mNArray)
 229         {
 230             free(inDestroy->mNArray);
 231             inDestroy->mNArray = NULL;
 232             inDestroy->mVArray = NULL;
 233         }
 234
 235         free(inDestroy);
 236         inDestroy = NULL;
 237     }
 238 }