开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > WEB邮件程序 > 查看源码
cgi.c
资源名称：sqwebmail-0.37a.38pre2.tar.gz　[点击查看]
上传用户：s81996212
上传日期：2007-01-04
资源大小：722k
文件大小：12k
源码类别：

WEB邮件程序

开发平台：

C/C++

cgi.c：源码内容
  1. /*
  2. ** Copyright 1998 - 1999 Double Precision, Inc.
  3. ** See COPYING for distribution information.
  4. */
  6. /*
  7. ** $Id: cgi.c,v 1.18 2000/06/17 18:41:13 mrsam Exp $
  8. */
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12. #include "cgi.h"
  14. #if HAVE_CONFIG_H
  15. #include "config.h"
  16. #endif
  18. #if HAVE_UNISTD_H
  19. #include <unistd.h>
  20. #endif
  22. #if TIME_WITH_SYS_TIME
  23. #include <sys/time.h>
  24. #include <time.h>
  25. #else
  26. #if HAVE_SYS_TIME_H
  27. #include <sys/time.h>
  28. #else
  29. #include <time.h>
  30. #endif
  31. #endif
  33. #ifndef CGIMAXARG
  34. #define CGIMAXARG 500000
  35. #endif
  37. #ifndef CGIMAXFORMDATAARG
  38. #define CGIMAXFORMDATAARG 2000000
  39. #endif
  41. #if CGIMAXARG < 256
  42. #error CGIMAXARG too small
  43. #endif
  45. #if CGIMAXFORMDATAARG < 1024
  46. #error CGIMAXFORMDATAARG too small
  47. #endif
  49. #if CGIFORMDATA
  51. #include <fcntl.h>
  52. #include <sys/types.h>
  53. #include <sys/stat.h>
  54. #include "rfc2045/rfc2045.h"
  56. static void cgi_formdata(unsigned long);
  58. #ifndef HAVE_STRNCASECMP
  59. extern int strncasecmp(const char *, const char *, size_t);
  60. #endif
  62. static int cgiformfd;
  63. static char hascgiformfd=0;
  64. static struct rfc2045 *rfc2045p=0;
  66. #endif
  68. extern void error(const char *);
  70. static void enomem()
  71. {
  72. error("Out of memory.");
  73. }
  75. static char *cgi_args=0;
  77. struct cgi_arglist *cgi_arglist=0;
  79. /*
  80. ** Set up CGI arguments.  Initializes cgi_arglist link list.
  81. **
  82. ** arg1<NUL>value1<NUL>arg2<NUL>value2<NUL> ... argn<NUL>valuen<NUL><NUL>
  83. */
  85. static void cgi_setup_1();
  87. void cgi_setup()
  88. {
  89. struct cgi_arglist *p;
  91. cgi_setup_1();
  93. /* Initialize the prev pointer */
  95. for (p=cgi_arglist; p; p=p->next)
  96. if (p->next)
  97. p->next->prev=p;
  98. }
  101. static void cgi_setup_1()
  102. {
  103. char *p=getenv("REQUEST_METHOD"), *q, *r;
  104. char *args;
  105. unsigned long cl;
  106. int c;
  107. struct cgi_arglist *argp;
  109. #if HAVE_LIBFCGI
  110. hascgiformfd=0;
  111. rfc2045p=0;
  112. if(cgi_args) {
  113. free(cgi_args);
  114. cgi_args=0;
  115. }
  116. if(cgi_arglist) {
  117. struct cgi_arglist *argp,*argP;
  118. for (argP=argp=cgi_arglist; argp; argp=argP) {
  119. /* argp->argname and argp->argvalue are a actually cgi_args,
  120.  * so don't free them
  121.  */
  122. argP = argp->next;
  123. if(argp) free(argp);
  124. }
  125. cgi_arglist=0;
  126. }
  127. #endif
  129. if (p && strcmp(p, "GET") == 0) /* This is a GET post */
  130. {
  131. args=getenv("QUERY_STRING");
  132. if (!args) return;
  133. if (strlen(args) > CGIMAXARG) enomem();
  134. cgi_args=malloc(strlen(args)+1); /* Extra insurance */
  135. if (!cgi_args) return;
  136. strcpy(cgi_args,args);
  137. args=cgi_args;
  138. }
  139. else if (p && strcmp(p, "POST") == 0)
  140. {
  141. args=getenv("CONTENT_TYPE");
  142. if (!args) return;
  144. #if CGIFORMDATA
  146. if (strncasecmp(args,"multipart/form-data;", 20) == 0)
  147. {
  148. args=getenv("CONTENT_LENGTH");
  149. if (!args) return;
  150. cl=atol(args);
  151. if (cl > CGIMAXFORMDATAARG)
  152. {
  153. printf("Content-Type: text/htmlnn");
  154. printf("<HTML><BODY><H1>Attachment size exceeds limit set by system administrator</H1></BODY></HTML>n");
  155. fake_exit(1);
  156. }
  157. cgi_formdata(cl);
  158. return;
  159. }
  160. #endif
  162. if (strcmp(args,"application/x-www-form-urlencoded"))
  163. return;
  164. args=getenv("CONTENT_LENGTH");
  165. if (!args) return;
  166. cl=atol(args);
  167. if (cl > CGIMAXARG)
  168. {
  169. printf("Content-Type: text/htmlnn");
  170. printf("<HTML><BODY><H1>Message size exceeds limit set by system administrator</H1></BODY></HTML>n");
  171. fake_exit(1);
  172. }
  173. cgi_args=malloc(cl+1); /* Extra insurance */
  174. if (!cgi_args) return;
  175. q=cgi_args;
  176. while (cl)
  177. {
  178. c=getchar();
  179. if (c < 0)
  180. {
  181. free(cgi_args);
  182. cgi_args=0;
  183. return;
  184. }
  185. *q++=c;
  186. --cl;
  187. }
  188. *q=0;
  189. args=cgi_args;
  190. }
  191. else return;
  193. q=args;
  194. while (*q)
  195. {
  196. argp=malloc(sizeof(*cgi_arglist));
  197. if (!argp) enomem();
  198. argp->next=cgi_arglist;
  199. cgi_arglist=argp;
  200. argp->argname=q;
  201. argp->argvalue="";
  202. p=q;
  203. while (*q && *q != '&')
  204. q++;
  205. if (*q) *q++=0;
  206. if ((r=strchr(p, '=')) != 0)
  207. {
  208. *r++='';
  209. argp->argvalue=r;
  210. cgiurldecode(r);
  211. }
  212. cgiurldecode(p);
  213. }
  214. }
  216. static char *cgiurlencode_common(const char *buf, const char *punct)
  217. {
  218. char *newbuf=0;
  219. size_t cnt=0;
  220. int pass;
  221. const char *p;
  222. static const char hex[]="0123456789ABCDEF";
  224. for (pass=0; pass<2; pass++)
  225. {
  226. if (pass && (newbuf=malloc(cnt+1)) == 0) enomem();
  227. cnt=0;
  228. for (p=buf; *p; p++)
  229. {
  230. if (strchr(punct, *p) || *p < 32 || *p >= 127)
  231. {
  232. if (pass)
  233. {
  234. newbuf[cnt]='%';
  235. newbuf[cnt+1]=hex[
  236. ((int)(unsigned char)*p) / 16];
  237. newbuf[cnt+2]=hex[ *p & 15 ];
  238. }
  239. cnt += 3;
  240. continue;
  241. }
  242. if (pass)
  243. newbuf[cnt]= *p == ' ' ? '+':*p;
  244. ++cnt;
  245. }
  246. }
  247. newbuf[cnt]=0;
  248. return (newbuf);
  249. }
  251. char *cgiurlencode(const char *buf)
  252. {
  253. return (cgiurlencode_common(buf, ""?;<>&=/:%+#"));
  254. }
  256. char *cgiurlencode_noamp(const char *buf)
  257. {
  258. return (cgiurlencode_common(buf, ""?<>=/:%+#"));
  259. }
  261. char *cgiurlencode_noeq(const char *buf)
  262. {
  263. return (cgiurlencode_common(buf, ""?;<>&/:%+#"));
  264. }
  266. void cgi_cleanup()
  267. {
  268. #if CGIFORMDATA
  270. if (hascgiformfd)
  271. {
  272. close(cgiformfd);
  273. hascgiformfd=0;
  274. }
  275. #endif
  277. }
  279. const char *cgi(const char *arg)
  280. {
  281. struct cgi_arglist *argp;
  283. for (argp=cgi_arglist; argp; argp=argp->next)
  284. if (strcmp(argp->argname, arg) == 0)
  285. return (argp->argvalue);
  286. return ("");
  287. }
  289. char *cgi_multiple(const char *arg, const char *sep)
  290. {
  291. struct cgi_arglist *argp;
  292. size_t l=1;
  293. char *buf;
  295. for (argp=cgi_arglist; argp; argp=argp->next)
  296. if (strcmp(argp->argname, arg) == 0)
  297. l += strlen(argp->argvalue)+strlen(sep);
  299. buf=malloc(l);
  300. if (!buf) return(0);
  301. *buf=0;
  303. /*
  304. ** Because the cgi list is build from the tail end up, we go backwards
  305. ** now, so that we return options in the same order they were selected.
  306. */
  308. argp=cgi_arglist;
  309. while (argp && argp->next)
  310. argp=argp->next;
  312. for (; argp; argp=argp->prev)
  313. if (strcmp(argp->argname, arg) == 0)
  314. {
  315. if (*buf) strcat(buf, sep);
  316. strcat(buf, argp->argvalue);
  317. }
  318. return (buf);
  319. }
  321. static char *nybble(char *p, int *n)
  322. {
  323. if ( *p >= '0' && *p <= '9')
  324. (*n) = (*n) * 16 + (*p++ - '0');
  325. else if ( *p >= 'A' && *p <= 'F')
  326. (*n) = (*n) * 16 + (*p++ - 'A' + 10);
  327. return (p);
  328. }
  330. void cgiurldecode(char *q)
  331. {
  332. char *p=q;
  333. int c;
  335. while (*q)
  336. {
  337. /*
  338. ** 0xA0 - Win32 versions of navigator convert TEXTAREA fillins
  339. ** of &nbsp; to 0xA0.
  340. */
  342. if (*q == '+' || *q == (char)0xA0)
  343. {
  344. *p++=' ';
  345. q++;
  346. continue;
  347. }
  348. if (*q != '%')
  349. {
  350. *p++=*q++;
  351. continue;
  352. }
  353. ++q;
  354. c=0;
  355. q=nybble(q, &c);
  356. q=nybble(q, &c);
  358. if ((char)c == (char)0xA0) c=' ';
  359. /* See above */
  361. if (c && c != 'r')
  362. /* Ignore CRs we get in TEXTAREAS */
  363. *p++=c;
  364. }
  365. *p++=0;
  366. }
  368. void cgi_put(const char *cginame, const char *cgivalue)
  369. {
  370. struct cgi_arglist *argp;
  372. for (argp=cgi_arglist; argp; argp=argp->next)
  373. if (strcmp(argp->argname, cginame) == 0)
  374. {
  375. argp->argvalue=cgivalue;
  376. return;
  377. }
  379. argp=malloc(sizeof(*cgi_arglist));
  380. if (!argp) enomem();
  381. argp->next=cgi_arglist;
  382. argp->prev=0;
  383. if (argp->next)
  384. argp->next->prev=argp;
  385. cgi_arglist=argp;
  386. argp->argname=cginame;
  387. argp->argvalue=cgivalue;
  388. }
  390. #if CGIFORMDATA
  392. /**************************************************************************/
  394. /* multipart/formdata decoding */
  396. static const char *disposition_name, *disposition_filename;
  398. static char *formargbuf;
  399. static char *formargptr;
  401. static int save_formdata(const char *p, size_t l, void *miscptr)
  402. {
  403. memcpy(formargptr, p, l);
  404. formargptr += l;
  405. return (0);
  406. }
  408. static void cgiformdecode(struct rfc2045 *p, struct rfc2045id *a, void *b)
  409. {
  410. const char *disposition;
  411. off_t start_pos, end_pos, start_body;
  412. char buf[512];
  413. int n;
  414. off_t dummy;
  416. a=a;
  417. b=b;
  419. rfc2045_dispositioninfo(p, &disposition, &disposition_name,
  420. &disposition_filename);
  422. if (!disposition || strcmp(disposition, "form-data")) return;
  423. if (!disposition_name || !*disposition_name) return;
  425. if (!disposition_filename || !*disposition_filename)
  426. {
  427. rfc2045_mimepos(p, &start_pos, &end_pos, &start_body,
  428. &dummy, &dummy);
  430. if (lseek(cgiformfd, start_body, SEEK_SET) == -1)
  431. enomem();
  433. formargbuf=malloc(end_pos - start_body+1);
  434. if (!formargbuf) enomem();
  435. formargptr=formargbuf;
  437. rfc2045_cdecode_start(p, &save_formdata, 0);
  438. while (start_body < end_pos)
  439. {
  440. n=sizeof(buf);
  441. if (n > end_pos - start_body)
  442. n=end_pos-start_body;
  443. n=read(cgiformfd, buf, n);
  444. if (n <= 0) enomem();
  445. rfc2045_cdecode(p, buf, n);
  446. start_body += n;
  447. }
  448. rfc2045_cdecode_end(p);
  450. *formargptr=0;
  451. {
  452. char *name=strdup(disposition_name);
  453. char *value=strdup(formargbuf);
  454. char *p, *q;
  456. /* Just like for GET/POSTs, strip CRs and convert
  457. ** 0xA0 to 0x20. */
  459. for (p=q=value; *p; p++)
  460. {
  461. if (*p == 'r') continue;
  462. *q++ = (char)*p == (char)0xA0 ? ' ':*p;
  463. }
  464. *q++='';
  465. cgi_put(name, value);
  466. }
  467. free(formargbuf);
  468. }
  469. }
  471. static const char *cgitempdir="/tmp";
  473. void cgiformdatatempdir(const char *p)
  474. {
  475. cgitempdir=p;
  476. }
  478. static void cgiformfdw(const char *p, size_t n)
  479. {
  480. while (n)
  481. {
  482. int k=write(cgiformfd, p, n);
  484. if (k <= 0) enomem();
  485. p += k;
  486. n -= k;
  487. }
  488. }
  490. static void cgi_formdata(unsigned long contentlength)
  491. {
  492. char pidbuf[MAXLONGSIZE];
  493. char timebuf[MAXLONGSIZE];
  494. char cntbuf[MAXLONGSIZE];
  495. time_t t;
  496. unsigned long cnt;
  497. int n;
  498. char *filename, *p;
  500. static const char fakeheader[]="MIME-Version: 1.0nContent-Type: ";
  501. char buf[BUFSIZ];
  503. sprintf(pidbuf, "%lu", (unsigned long)getpid());
  504. time(&t);
  505. sprintf(timebuf, "%lu", (unsigned long)t);
  506. cnt=0;
  508. buf[sizeof(buf)-1]=0;
  509. if (gethostname(buf, sizeof(buf)-1) != 0)
  510. buf[0]='';
  512. do
  513. {
  514. sprintf(cntbuf, "%lu", (unsigned long)cnt);
  515. filename=malloc(strlen(pidbuf)+strlen(timebuf)+strlen(cntbuf)
  516. +strlen(cgitempdir)+strlen(buf)+10);
  517. if (!filename) enomem();
  518. sprintf(filename, "%s/%s.%s_%s.%s", cgitempdir,
  519. timebuf, pidbuf, cntbuf, buf);
  520. cgiformfd=open(filename, O_RDWR | O_CREAT | O_EXCL, 0644);
  521. } while (cgiformfd < 0);
  522. unlink(filename); /* !!!MUST WORK!!! */
  523. hascgiformfd=1;
  524. p=getenv("CONTENT_TYPE");
  525. free(filename);
  526. cgiformfdw(fakeheader, strlen(fakeheader));
  527. cgiformfdw(p, strlen(p));
  528. cgiformfdw("nn", 2);
  530. clearerr(stdin);
  532. while (contentlength)
  533. {
  534. n=sizeof(buf);
  535. if (n > contentlength) n=contentlength;
  537. n=fread(buf, 1, n, stdin);
  538. if (n <= 0)
  539. enomem();
  540. cgiformfdw(buf, n);
  541. contentlength -= n;
  542. }
  544. rfc2045p=rfc2045_alloc();
  545. lseek(cgiformfd, 0L, SEEK_SET);
  546. while ((n=read(cgiformfd, buf, sizeof(buf))) > 0)
  547. rfc2045_parse(rfc2045p, buf, n);
  548. rfc2045_decode(rfc2045p, &cgiformdecode, 0);
  550. }
  552. struct cgigetfileinfo {
  553. int (*start_file)(const char *, const char *);
  554. int (*file)(const char *, size_t, void *);
  555. void (*end_file)(void);
  556. size_t filenum;
  557. } ;
  560. static void cgifiledecode(struct rfc2045 *p, struct rfc2045id *a, void *b)
  561. {
  562. const char *disposition;
  563. off_t start_pos, end_pos, start_body;
  564. char buf[512];
  565. int n;
  566. struct cgigetfileinfo *c;
  567. off_t dummy;
  569. a=a;
  570. c=(struct cgigetfileinfo *)b;
  572. if (c->filenum == 0) return; /* Already retrieved this one. */
  574. rfc2045_dispositioninfo(p, &disposition, &disposition_name,
  575. &disposition_filename);
  577. if (!disposition || strcmp(disposition, "form-data")) return;
  579. if (!disposition_name || !*disposition_name) return;
  581. if (!disposition_filename || !*disposition_filename) return;
  582. rfc2045_mimepos(p, &start_pos, &end_pos, &start_body,
  583. &dummy, &dummy);
  585. if (start_body == end_pos) /* NULL FILE */
  586. return;
  588. if ( --c->filenum ) return; /* Not this one */
  590. if ( (*c->start_file)(disposition_name, disposition_filename) )
  591. return;
  593. if (lseek(cgiformfd, start_body, SEEK_SET) == -1)
  594. enomem();
  596. rfc2045_cdecode_start(p, c->file, 0);
  597. while (start_body < end_pos)
  598. {
  599. n=sizeof(buf);
  600. if (n > end_pos - start_body)
  601. n=end_pos-start_body;
  602. n=read(cgiformfd, buf, n);
  603. if (n <= 0) enomem();
  604. rfc2045_cdecode(p, buf, n);
  605. start_body += n;
  606. }
  607. rfc2045_cdecode_end(p);
  608. (*c->end_file)();
  609. }
  611. int cgi_getfiles( int (*start_file)(const char *, const char *),
  612. int (*file)(const char *, size_t, void *),
  613. void (*end_file)(void), size_t filenum)
  614. {
  615. struct cgigetfileinfo gfi={start_file, file, end_file, filenum};
  617. if (rfc2045p) rfc2045_decode(rfc2045p, &cgifiledecode, &gfi);
  618. if (gfi.filenum) return (-1);
  619. return (0);
  620. }
  622. #endif