← Back to branch summary

~ubuntu-branches/ubuntu/lucid/curl/lucid-201101212007

« back to all changes in this revision

Viewing changes to lib/formdata.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2008-02-08 11:20:41 UTC
  • mto: (3.1.1 lenny) (1.2.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 26.
  • Revision ID: james.westby@ubuntu.com-20080208112041-hed7sb5r6ghmjf8v
Tags: upstream-7.18.0
Import upstream version 7.18.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/formdata.c
18
18
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19
19
 * KIND, either express or implied.
20
20
 *
21
 
 * $Id: formdata.c,v 1.102 2007-09-27 01:45:23 danf Exp $
 
21
 * $Id: formdata.c,v 1.103 2007-11-05 09:45:09 bagder Exp $
22
22
 ***************************************************************************/
23
23
 
24
24
/*
187
187
  else
188
188
    return NULL;
189
189
 
190
 
  if (parent_post) {
 
190
  if(parent_post) {
191
191
    /* now, point our 'more' to the original 'more' */
192
192
    post->more = parent_post->more;
193
193
 
224
224
  form_info = (FormInfo *)malloc(sizeof(FormInfo));
225
225
  if(form_info) {
226
226
    memset(form_info, 0, sizeof(FormInfo));
227
 
    if (value)
 
227
    if(value)
228
228
      form_info->value = value;
229
 
    if (contenttype)
 
229
    if(contenttype)
230
230
      form_info->contenttype = contenttype;
231
231
    form_info->flags = HTTPPOST_FILENAME;
232
232
  }
233
233
  else
234
234
    return NULL;
235
235
 
236
 
  if (parent_form_info) {
 
236
  if(parent_form_info) {
237
237
    /* now, point our 'more' to the original 'more' */
238
238
    form_info->more = parent_form_info->more;
239
239
 
316
316
  bool add = FALSE;
317
317
  char *buffer;
318
318
 
319
 
  if (buffer_length)
 
319
  if(buffer_length)
320
320
    length = buffer_length;
321
321
  else if(src) {
322
322
    length = strlen(src);
327
327
    return strdup((char *)"");
328
328
 
329
329
  buffer = (char*)malloc(length+add);
330
 
  if (!buffer)
 
330
  if(!buffer)
331
331
    return NULL; /* fail */
332
332
 
333
333
  memcpy(buffer, src, length);
334
334
 
335
335
  /* if length unknown do null termination */
336
 
  if (add)
 
336
  if(add)
337
337
    buffer[length] = '\0';
338
338
 
339
339
  return buffer;
418
418
  /*
419
419
   * Loop through all the options set. Break if we have an error to report.
420
420
   */
421
 
  while (return_value == CURL_FORMADD_OK) {
 
421
  while(return_value == CURL_FORMADD_OK) {
422
422
 
423
423
    /* first see if we have more parts of the array param */
424
 
    if ( array_state ) {
 
424
    if( array_state ) {
425
425
      /* get the upcoming option from the given array */
426
426
      option = forms->option;
427
427
      array_value = (char *)forms->value;
428
428
 
429
429
      forms++; /* advance this to next entry */
430
 
      if (CURLFORM_END == option) {
 
430
      if(CURLFORM_END == option) {
431
431
        /* end of array state */
432
432
        array_state = FALSE;
433
433
        continue;
436
436
    else {
437
437
      /* This is not array-state, get next option */
438
438
      option = va_arg(params, CURLformoption);
439
 
      if (CURLFORM_END == option)
 
439
      if(CURLFORM_END == option)
440
440
        break;
441
441
    }
442
442
 
447
447
        return_value = CURL_FORMADD_ILLEGAL_ARRAY;
448
448
      else {
449
449
        forms = va_arg(params, struct curl_forms *);
450
 
        if (forms)
 
450
        if(forms)
451
451
          array_state = TRUE;
452
452
        else
453
453
          return_value = CURL_FORMADD_NULL;
465
465
      current_form->flags |= HTTPPOST_PTRNAME; /* fall through */
466
466
#endif
467
467
    case CURLFORM_COPYNAME:
468
 
      if (current_form->name)
 
468
      if(current_form->name)
469
469
        return_value = CURL_FORMADD_OPTION_TWICE;
470
470
      else {
471
471
        char *name = array_state?
472
472
          array_value:va_arg(params, char *);
473
 
        if (name)
 
473
        if(name)
474
474
          current_form->name = name; /* store for the moment */
475
475
        else
476
476
          return_value = CURL_FORMADD_NULL;
477
477
      }
478
478
      break;
479
479
    case CURLFORM_NAMELENGTH:
480
 
      if (current_form->namelength)
 
480
      if(current_form->namelength)
481
481
        return_value = CURL_FORMADD_OPTION_TWICE;
482
482
      else
483
483
        current_form->namelength =
490
490
    case CURLFORM_PTRCONTENTS:
491
491
      current_form->flags |= HTTPPOST_PTRCONTENTS; /* fall through */
492
492
    case CURLFORM_COPYCONTENTS:
493
 
      if (current_form->value)
 
493
      if(current_form->value)
494
494
        return_value = CURL_FORMADD_OPTION_TWICE;
495
495
      else {
496
496
        char *value =
497
497
          array_state?array_value:va_arg(params, char *);
498
 
        if (value)
 
498
        if(value)
499
499
          current_form->value = value; /* store for the moment */
500
500
        else
501
501
          return_value = CURL_FORMADD_NULL;
502
502
      }
503
503
      break;
504
504
    case CURLFORM_CONTENTSLENGTH:
505
 
      if (current_form->contentslength)
 
505
      if(current_form->contentslength)
506
506
        return_value = CURL_FORMADD_OPTION_TWICE;
507
507
      else
508
508
        current_form->contentslength =
511
511
 
512
512
      /* Get contents from a given file name */
513
513
    case CURLFORM_FILECONTENT:
514
 
      if (current_form->flags != 0)
 
514
      if(current_form->flags != 0)
515
515
        return_value = CURL_FORMADD_OPTION_TWICE;
516
516
      else {
517
517
        const char *filename = array_state?
518
518
          array_value:va_arg(params, char *);
519
 
        if (filename) {
 
519
        if(filename) {
520
520
          current_form->value = strdup(filename);
521
521
          if(!current_form->value)
522
522
            return_value = CURL_FORMADD_MEMORY;
536
536
        const char *filename = array_state?array_value:
537
537
          va_arg(params, char *);
538
538
 
539
 
        if (current_form->value) {
540
 
          if (current_form->flags & HTTPPOST_FILENAME) {
541
 
            if (filename) {
542
 
              if ((current_form = AddFormInfo(strdup(filename),
 
539
        if(current_form->value) {
 
540
          if(current_form->flags & HTTPPOST_FILENAME) {
 
541
            if(filename) {
 
542
              if((current_form = AddFormInfo(strdup(filename),
543
543
                                              NULL, current_form)) == NULL)
544
544
                return_value = CURL_FORMADD_MEMORY;
545
545
            }
550
550
            return_value = CURL_FORMADD_OPTION_TWICE;
551
551
        }
552
552
        else {
553
 
          if (filename) {
 
553
          if(filename) {
554
554
            current_form->value = strdup(filename);
555
555
            if(!current_form->value)
556
556
              return_value = CURL_FORMADD_MEMORY;
570
570
        const char *filename = array_state?array_value:
571
571
          va_arg(params, char *);
572
572
 
573
 
        if (current_form->value) {
574
 
          if (current_form->flags & HTTPPOST_BUFFER) {
575
 
            if (filename) {
576
 
              if ((current_form = AddFormInfo(strdup(filename),
 
573
        if(current_form->value) {
 
574
          if(current_form->flags & HTTPPOST_BUFFER) {
 
575
            if(filename) {
 
576
              if((current_form = AddFormInfo(strdup(filename),
577
577
                                              NULL, current_form)) == NULL)
578
578
                return_value = CURL_FORMADD_MEMORY;
579
579
            }
584
584
            return_value = CURL_FORMADD_OPTION_TWICE;
585
585
        }
586
586
        else {
587
 
          if (filename) {
 
587
          if(filename) {
588
588
            current_form->value = strdup(filename);
589
589
            if(!current_form->value)
590
590
              return_value = CURL_FORMADD_MEMORY;
598
598
 
599
599
    case CURLFORM_BUFFERPTR:
600
600
        current_form->flags |= HTTPPOST_PTRBUFFER;
601
 
      if (current_form->buffer)
 
601
      if(current_form->buffer)
602
602
        return_value = CURL_FORMADD_OPTION_TWICE;
603
603
      else {
604
604
        char *buffer =
605
605
          array_state?array_value:va_arg(params, char *);
606
 
        if (buffer)
 
606
        if(buffer)
607
607
          current_form->buffer = buffer; /* store for the moment */
608
608
        else
609
609
          return_value = CURL_FORMADD_NULL;
611
611
      break;
612
612
 
613
613
    case CURLFORM_BUFFERLENGTH:
614
 
      if (current_form->bufferlength)
 
614
      if(current_form->bufferlength)
615
615
        return_value = CURL_FORMADD_OPTION_TWICE;
616
616
      else
617
617
        current_form->bufferlength =
622
622
      {
623
623
        const char *contenttype =
624
624
          array_state?array_value:va_arg(params, char *);
625
 
        if (current_form->contenttype) {
626
 
          if (current_form->flags & HTTPPOST_FILENAME) {
627
 
            if (contenttype) {
628
 
              if ((current_form = AddFormInfo(NULL,
 
625
        if(current_form->contenttype) {
 
626
          if(current_form->flags & HTTPPOST_FILENAME) {
 
627
            if(contenttype) {
 
628
              if((current_form = AddFormInfo(NULL,
629
629
                                              strdup(contenttype),
630
630
                                              current_form)) == NULL)
631
631
                return_value = CURL_FORMADD_MEMORY;
637
637
            return_value = CURL_FORMADD_OPTION_TWICE;
638
638
        }
639
639
        else {
640
 
          if (contenttype) {
 
640
          if(contenttype) {
641
641
            current_form->contenttype = strdup(contenttype);
642
642
            if(!current_form->contenttype)
643
643
              return_value = CURL_FORMADD_MEMORY;
692
692
    for(form = first_form;
693
693
        form != NULL;
694
694
        form = form->more) {
695
 
      if ( ((!form->name || !form->value) && !post) ||
 
695
      if( ((!form->name || !form->value) && !post) ||
696
696
           ( (form->contentslength) &&
697
697
             (form->flags & HTTPPOST_FILENAME) ) ||
698
698
           ( (form->flags & HTTPPOST_FILENAME) &&
709
709
        break;
710
710
      }
711
711
      else {
712
 
        if ( ((form->flags & HTTPPOST_FILENAME) ||
 
712
        if( ((form->flags & HTTPPOST_FILENAME) ||
713
713
              (form->flags & HTTPPOST_BUFFER)) &&
714
714
             !form->contenttype ) {
715
715
          /* our contenttype is missing */
721
721
          }
722
722
          form->contenttype_alloc = TRUE;
723
723
        }
724
 
        if ( !(form->flags & HTTPPOST_PTRNAME) &&
 
724
        if( !(form->flags & HTTPPOST_PTRNAME) &&
725
725
             (form == first_form) ) {
726
726
          /* copy name (without strdup; possibly contains null characters) */
727
727
          form->name = memdup(form->name, form->namelength);
728
 
          if (!form->name) {
 
728
          if(!form->name) {
729
729
            return_value = CURL_FORMADD_MEMORY;
730
730
            break;
731
731
          }
732
732
          form->name_alloc = TRUE;
733
733
        }
734
 
        if ( !(form->flags & HTTPPOST_FILENAME) &&
 
734
        if( !(form->flags & HTTPPOST_FILENAME) &&
735
735
             !(form->flags & HTTPPOST_READFILE) &&
736
736
             !(form->flags & HTTPPOST_PTRCONTENTS) &&
737
737
             !(form->flags & HTTPPOST_PTRBUFFER) ) {
738
738
          /* copy value (without strdup; possibly contains null characters) */
739
739
          form->value = memdup(form->value, form->contentslength);
740
 
          if (!form->value) {
 
740
          if(!form->value) {
741
741
            return_value = CURL_FORMADD_MEMORY;
742
742
            break;
743
743
          }
756
756
          break;
757
757
        }
758
758
 
759
 
        if (form->contenttype)
 
759
        if(form->contenttype)
760
760
          prevtype = form->contenttype;
761
761
      }
762
762
    }
780
780
 
781
781
  /* always delete the allocated memory before returning */
782
782
  form = first_form;
783
 
  while (form != NULL) {
 
783
  while(form != NULL) {
784
784
    FormInfo *delete_form;
785
785
 
786
786
    delete_form = form;
820
820
{
821
821
  struct FormData *newform = (struct FormData *)
822
822
    malloc(sizeof(struct FormData));
823
 
  if (!newform)
 
823
  if(!newform)
824
824
    return CURLE_OUT_OF_MEMORY;
825
825
  newform->next = NULL;
826
826
 
829
829
    length = strlen((char *)line);
830
830
 
831
831
  newform->line = (char *)malloc(length+1);
832
 
  if (!newform->line) {
 
832
  if(!newform->line) {
833
833
    free(newform);
834
834
    return CURLE_OUT_OF_MEMORY;
835
835
  }
845
845
  else
846
846
    *formp = newform;
847
847
 
848
 
  if (size) {
 
848
  if(size) {
849
849
    if((type == FORM_DATA) || (type == FORM_CONTENT))
850
850
      *size += length;
851
851
    else {
896
896
    free(form->line); /* free the line */
897
897
    free(form);       /* free the struct */
898
898
 
899
 
  } while ((form = next) != NULL); /* continue */
 
899
  } while((form = next) != NULL); /* continue */
900
900
 
901
901
  *form_ptr = NULL;
902
902
}
920
920
 
921
921
  do {
922
922
    next=form->next;  /* the following form line */
923
 
    if (form->type == FORM_DATA) {
 
923
    if(form->type == FORM_DATA) {
924
924
      rc = Curl_convert_to_network(data, form->line, form->length);
925
925
      /* Curl_convert_to_network calls failf if unsuccessful */
926
 
      if (rc != CURLE_OK)
 
926
      if(rc != CURLE_OK)
927
927
        return rc;
928
928
    }
929
 
  } while ((form = next) != NULL); /* continue */
 
929
  } while((form = next) != NULL); /* continue */
930
930
  return CURLE_OK;
931
931
}
932
932
#endif /* CURL_DOES_CONVERSIONS */
944
944
  struct FormData *data, *ptr;
945
945
 
946
946
  rc = Curl_getFormData(&data, form, NULL, &size);
947
 
  if (rc != CURLE_OK)
 
947
  if(rc != CURLE_OK)
948
948
    return (int)rc;
949
949
 
950
950
  for (ptr = data; ptr; ptr = ptr->next) {
951
 
    if (ptr->type == FORM_FILE) {
 
951
    if(ptr->type == FORM_FILE) {
952
952
      char buffer[8192];
953
953
      size_t nread;
954
954
      struct Form temp;
957
957
 
958
958
      do {
959
959
        nread = readfromfile(&temp, buffer, sizeof(buffer));
960
 
        if ((nread == (size_t) -1) || (nread != append(arg, buffer, nread))) {
961
 
          if (temp.fp) {
 
960
        if((nread == (size_t) -1) || (nread != append(arg, buffer, nread))) {
 
961
          if(temp.fp) {
962
962
            fclose(temp.fp);
963
963
          }
964
964
          Curl_formclean(&data);
965
965
          return -1;
966
966
        }
967
 
      } while (nread == sizeof(buffer));
 
967
      } while(nread == sizeof(buffer));
968
968
    } else {
969
 
      if (ptr->length != append(arg, ptr->line, ptr->length)) {
 
969
      if(ptr->length != append(arg, ptr->line, ptr->length)) {
970
970
        Curl_formclean(&data);
971
971
        return -1;
972
972
      }
1005
1005
      free(form->showfilename); /* free the faked file name */
1006
1006
    free(form);       /* free the struct */
1007
1007
 
1008
 
  } while ((form = next) != NULL); /* continue */
 
1008
  } while((form = next) != NULL); /* continue */
1009
1009
}
1010
1010
 
1011
1011
#ifndef HAVE_BASENAME
1110
1110
                        "Content-Type: multipart/form-data",
1111
1111
                        boundary);
1112
1112
 
1113
 
  if (result) {
 
1113
  if(result) {
1114
1114
    free(boundary);
1115
1115
    return result;
1116
1116
  }
1123
1123
 
1124
1124
    if(size) {
1125
1125
      result = AddFormDataf(&form, &size, "\r\n");
1126
 
      if (result)
 
1126
      if(result)
1127
1127
        break;
1128
1128
    }
1129
1129
 
1130
1130
    /* boundary */
1131
1131
    result = AddFormDataf(&form, &size, "--%s\r\n", boundary);
1132
 
    if (result)
 
1132
    if(result)
1133
1133
      break;
1134
1134
 
1135
1135
    /* Maybe later this should be disabled when a custom_content_type is
1138
1138
    */
1139
1139
    result = AddFormDataf(&form, &size,
1140
1140
                          "Content-Disposition: form-data; name=\"");
1141
 
    if (result)
 
1141
    if(result)
1142
1142
      break;
1143
1143
 
1144
1144
    result = AddFormData(&form, FORM_DATA, post->name, post->namelength,
1145
1145
                         &size);
1146
 
    if (result)
 
1146
    if(result)
1147
1147
      break;
1148
1148
 
1149
1149
    result = AddFormDataf(&form, &size, "\"");
1150
 
    if (result)
 
1150
    if(result)
1151
1151
      break;
1152
1152
 
1153
1153
    if(post->more) {
1160
1160
                            "\r\nContent-Type: multipart/mixed,"
1161
1161
                            " boundary=%s\r\n",
1162
1162
                            fileboundary);
1163
 
      if (result)
 
1163
      if(result)
1164
1164
        break;
1165
1165
    }
1166
1166
 
1183
1183
                              fileboundary,
1184
1184
                              (file->showfilename?file->showfilename:
1185
1185
                               filebasename));
1186
 
        if (filebasename)
 
1186
        if(filebasename)
1187
1187
          free(filebasename);
1188
 
        if (result)
 
1188
        if(result)
1189
1189
          break;
1190
1190
      }
1191
1191
      else if((post->flags & HTTPPOST_FILENAME) ||
1198
1198
                              "; filename=\"%s\"",
1199
1199
                              (post->showfilename?post->showfilename:
1200
1200
                               filebasename));
1201
 
        if (filebasename)
 
1201
        if(filebasename)
1202
1202
          free(filebasename);
1203
1203
 
1204
 
        if (result)
 
1204
        if(result)
1205
1205
          break;
1206
1206
      }
1207
1207
 
1210
1210
        result = AddFormDataf(&form, &size,
1211
1211
                              "\r\nContent-Type: %s",
1212
1212
                              file->contenttype);
1213
 
        if (result)
 
1213
        if(result)
1214
1214
          break;
1215
1215
      }
1216
1216
 
1218
1218
      while( curList ) {
1219
1219
        /* Process the additional headers specified for this form */
1220
1220
        result = AddFormDataf( &form, &size, "\r\n%s", curList->data );
1221
 
        if (result)
 
1221
        if(result)
1222
1222
          break;
1223
1223
        curList = curList->next;
1224
1224
      }
1225
 
      if (result) {
 
1225
      if(result) {
1226
1226
        Curl_formclean(&firstform);
1227
1227
        free(boundary);
1228
1228
        return result;
1240
1240
        /* this is not a text content, mention our binary encoding */
1241
1241
        result = AddFormDataf(&form, &size,
1242
1242
                              "\r\nContent-Transfer-Encoding: binary");
1243
 
        if (result)
 
1243
        if(result)
1244
1244
          break;
1245
1245
      }
1246
1246
#endif
1247
1247
 
1248
1248
      result = AddFormDataf(&form, &size, "\r\n\r\n");
1249
 
      if (result)
 
1249
      if(result)
1250
1250
        break;
1251
1251
 
1252
1252
      if((post->flags & HTTPPOST_FILENAME) ||
1278
1278
             */
1279
1279
            size_t nread;
1280
1280
            char buffer[512];
1281
 
            while ((nread = fread(buffer, 1, sizeof(buffer), fileread)) != 0) {
 
1281
            while((nread = fread(buffer, 1, sizeof(buffer), fileread)) != 0) {
1282
1282
              result = AddFormData(&form, FORM_CONTENT, buffer, nread, &size);
1283
 
              if (result)
 
1283
              if(result)
1284
1284
                break;
1285
1285
            }
1286
1286
          }
1287
1287
 
1288
 
          if (result) {
 
1288
          if(result) {
1289
1289
            Curl_formclean(&firstform);
1290
1290
            free(boundary);
1291
1291
            return result;
1305
1305
        }
1306
1306
 
1307
1307
      }
1308
 
      else if (post->flags & HTTPPOST_BUFFER) {
 
1308
      else if(post->flags & HTTPPOST_BUFFER) {
1309
1309
        /* include contents of buffer */
1310
1310
        result = AddFormData(&form, FORM_CONTENT, post->buffer,
1311
1311
                             post->bufferlength, &size);
1312
 
          if (result)
 
1312
          if(result)
1313
1313
            break;
1314
1314
      }
1315
1315
 
1317
1317
        /* include the contents we got */
1318
1318
        result = AddFormData(&form, FORM_CONTENT, post->contents,
1319
1319
                             post->contentslength, &size);
1320
 
        if (result)
 
1320
        if(result)
1321
1321
          break;
1322
1322
      }
1323
 
    } while ((file = file->more) != NULL); /* for each specified file for this field */
1324
 
    if (result) {
 
1323
    } while((file = file->more) != NULL); /* for each specified file for this field */
 
1324
    if(result) {
1325
1325
      Curl_formclean(&firstform);
1326
1326
      free(boundary);
1327
1327
      return result;
1334
1334
                           "\r\n--%s--",
1335
1335
                           fileboundary);
1336
1336
      free(fileboundary);
1337
 
      if (result)
 
1337
      if(result)
1338
1338
        break;
1339
1339
    }
1340
1340
 
1341
 
  } while ((post = post->next) != NULL); /* for each field */
1342
 
  if (result) {
 
1341
  } while((post = post->next) != NULL); /* for each field */
 
1342
  if(result) {
1343
1343
    Curl_formclean(&firstform);
1344
1344
    free(boundary);
1345
1345
    return result;
1349
1349
  result = AddFormDataf(&form, &size,
1350
1350
                       "\r\n--%s--\r\n",
1351
1351
                       boundary);
1352
 
  if (result) {
 
1352
  if(result) {
1353
1353
    Curl_formclean(&firstform);
1354
1354
    free(boundary);
1355
1355
    return result;
1488
1488
  int result;
1489
1489
  va_list arg;
1490
1490
  va_start(arg, last_post);
1491
 
  if ((result = FormAdd(httppost, last_post, arg)))
 
1491
  if((result = FormAdd(httppost, last_post, arg)))
1492
1492
    fprintf (stderr, "ERROR doing FormAdd ret: %d action: %s\n", result,
1493
1493
             errormsg);
1494
1494
  va_end(arg);
1539
1539
  (void) argc;
1540
1540
  (void) argv;
1541
1541
 
1542
 
  if (FormAddTest("simple COPYCONTENTS test", &httppost, &last_post,
 
1542
  if(FormAddTest("simple COPYCONTENTS test", &httppost, &last_post,
1543
1543
                  CURLFORM_COPYNAME, name1, CURLFORM_COPYCONTENTS, value1,
1544
1544
                  CURLFORM_END))
1545
1545
    ++errors;
1546
 
  if (FormAddTest("COPYCONTENTS  + CONTENTTYPE test", &httppost, &last_post,
 
1546
  if(FormAddTest("COPYCONTENTS  + CONTENTTYPE test", &httppost, &last_post,
1547
1547
                  CURLFORM_COPYNAME, name2, CURLFORM_COPYCONTENTS, value2,
1548
1548
                  CURLFORM_CONTENTTYPE, type2, CURLFORM_END))
1549
1549
    ++errors;
1551
1551
     correctly */
1552
1552
  name3[1] = '\0';
1553
1553
  value3[1] = '\0';
1554
 
  if (FormAddTest("PTRNAME + NAMELENGTH + COPYNAME + CONTENTSLENGTH test",
 
1554
  if(FormAddTest("PTRNAME + NAMELENGTH + COPYNAME + CONTENTSLENGTH test",
1555
1555
                  &httppost, &last_post,
1556
1556
                  CURLFORM_PTRNAME, name3, CURLFORM_COPYCONTENTS, value3,
1557
1557
                  CURLFORM_CONTENTSLENGTH, value3length,
1558
1558
                  CURLFORM_NAMELENGTH, name3length, CURLFORM_END))
1559
1559
    ++errors;
1560
 
  if (FormAddTest("simple PTRCONTENTS test", &httppost, &last_post,
 
1560
  if(FormAddTest("simple PTRCONTENTS test", &httppost, &last_post,
1561
1561
                  CURLFORM_COPYNAME, name4, CURLFORM_PTRCONTENTS, value4,
1562
1562
                  CURLFORM_END))
1563
1563
    ++errors;
1564
1564
  /* make null character at start to check that contentslength works
1565
1565
     correctly */
1566
1566
  value5[1] = '\0';
1567
 
  if (FormAddTest("PTRCONTENTS + CONTENTSLENGTH test", &httppost, &last_post,
 
1567
  if(FormAddTest("PTRCONTENTS + CONTENTSLENGTH test", &httppost, &last_post,
1568
1568
                  CURLFORM_COPYNAME, name5, CURLFORM_PTRCONTENTS, value5,
1569
1569
                  CURLFORM_CONTENTSLENGTH, value5length, CURLFORM_END))
1570
1570
    ++errors;
1571
1571
  /* make null character at start to check that contentslength works
1572
1572
     correctly */
1573
1573
  value6[1] = '\0';
1574
 
  if (FormAddTest("PTRCONTENTS + CONTENTSLENGTH + CONTENTTYPE test",
 
1574
  if(FormAddTest("PTRCONTENTS + CONTENTSLENGTH + CONTENTTYPE test",
1575
1575
                  &httppost, &last_post,
1576
1576
                  CURLFORM_COPYNAME, name6, CURLFORM_PTRCONTENTS, value6,
1577
1577
                  CURLFORM_CONTENTSLENGTH, value6length,
1578
1578
                  CURLFORM_CONTENTTYPE, type6, CURLFORM_END))
1579
1579
    ++errors;
1580
 
  if (FormAddTest("FILE + CONTENTTYPE test", &httppost, &last_post,
 
1580
  if(FormAddTest("FILE + CONTENTTYPE test", &httppost, &last_post,
1581
1581
                  CURLFORM_COPYNAME, name7, CURLFORM_FILE, value7,
1582
1582
                  CURLFORM_CONTENTTYPE, type7, CURLFORM_END))
1583
1583
    ++errors;
1584
 
  if (FormAddTest("FILE1 + FILE2 test", &httppost, &last_post,
 
1584
  if(FormAddTest("FILE1 + FILE2 test", &httppost, &last_post,
1585
1585
                  CURLFORM_COPYNAME, name8, CURLFORM_FILE, value7,
1586
1586
                  CURLFORM_FILE, value8, CURLFORM_END))
1587
1587
    ++errors;
1588
 
  if (FormAddTest("FILE1 + FILE2 + FILE3 test", &httppost, &last_post,
 
1588
  if(FormAddTest("FILE1 + FILE2 + FILE3 test", &httppost, &last_post,
1589
1589
                  CURLFORM_COPYNAME, name9, CURLFORM_FILE, value7,
1590
1590
                  CURLFORM_FILE, value8, CURLFORM_FILE, value7, CURLFORM_END))
1591
1591
    ++errors;
1596
1596
  forms[2].option = CURLFORM_FILE;
1597
1597
  forms[2].value  = value7;
1598
1598
  forms[3].option  = CURLFORM_END;
1599
 
  if (FormAddTest("FILE1 + FILE2 + FILE3 ARRAY test", &httppost, &last_post,
 
1599
  if(FormAddTest("FILE1 + FILE2 + FILE3 ARRAY test", &httppost, &last_post,
1600
1600
                  CURLFORM_COPYNAME, name10, CURLFORM_ARRAY, forms,
1601
1601
                  CURLFORM_END))
1602
1602
    ++errors;
1603
 
  if (FormAddTest("FILECONTENT test", &httppost, &last_post,
 
1603
  if(FormAddTest("FILECONTENT test", &httppost, &last_post,
1604
1604
                  CURLFORM_COPYNAME, name11, CURLFORM_FILECONTENT, value7,
1605
1605
                  CURLFORM_END))
1606
1606
    ++errors;
1628
1628
  fprintf(stdout, "size: ");
1629
1629
  fprintf(stdout, CURL_FORMAT_OFF_T, size);
1630
1630
  fprintf(stdout, "\n");
1631
 
  if (errors)
 
1631
  if(errors)
1632
1632
    fprintf(stdout, "\n==> %d Test(s) failed!\n", errors);
1633
1633
  else
1634
1634
    fprintf(stdout, "\nAll Tests seem to have worked (please check output)\n");