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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机WAP编程 > 查看源码
cookies.c
资源名称：gateway-1.2.1　[点击查看]
上传用户：gzpyjq
上传日期：2013-01-31
资源大小：1852k
文件大小：14k
源码类别：

手机WAP编程

开发平台：

WINDOWS

cookies.c：源码内容
  1. /*
  2.  * Module: cookies.c
  3.  *
  4.  * Description: Implements a minimal cookie handler for session persistence.
  5.  *
  6.  * References: RFC 2109
  7.  *
  8.  * Author: Paul Keogh, ANAM Wireless Internet Solutions
  9.  *
  10.  * Date: May 2000
  11.  */
  13. #include <string.h>
  14. #include <ctype.h>
  16. #include "gwlib/gwlib.h"
  17. #include "wsp.h"
  18. #include "cookies.h"
  20. /* Statics */
  22. static Octstr *get_header_value(Octstr*);
  23. static Cookie *parse_cookie(Octstr*);
  24. static void add_cookie_to_cache(const WSPMachine*, Cookie*);
  25. static void expire_cookies(List*);
  26. static void cookie_destroy(void*);
  27. static int have_cookie(List*, Cookie*);
  28. static int parse_http_date(const char*);
  29. static Cookie emptyCookie;
  32. Cookie *cookie_create(void)
  33. {
  34. Cookie *p;
  36. p = gw_malloc(sizeof(Cookie)); /* Never returns NULL */
  38. *p = emptyCookie;
  39. p -> max_age = -1;
  40. time (&p -> birth);
  41. return p;
  42. }
  44. void cookies_destroy(List *cookies) {
  45. gwlib_assert_init();
  47. if (cookies == NULL)
  48. return;
  50. list_destroy(cookies, cookie_destroy);
  51. }
  54. int get_cookies (List *headers, const WSPMachine *sm)
  55. {
  56. Octstr *header = NULL;
  57. Octstr *value = NULL;
  58. Cookie *cookie = NULL;
  59. long pos = 0;
  61. /* 
  62.      * This can happen if the user aborts while the HTTP request is pending from the server.
  63.  * In that case, the session machine is destroyed and is not available to this function
  64.  * for cookie caching.
  65.  */
  67. if (sm == NULL) {
  68. info (0, "No session machine for cookie retrieval");
  69. return 0;
  70. }
  72. for (pos = 0; pos < list_len (headers); pos++) {
  73. header = list_get(headers, pos);
  74. debug ("wap.wsp.http", 0, "get_cookies: Examining header (%s)", octstr_get_cstr (header));
  75. if (strncasecmp ("set-cookie", octstr_get_cstr (header),10) == 0) {
  76. debug ("wap.wsp.http", 0, "Caching cookie (%s)", octstr_get_cstr (header));
  78. if ((value = get_header_value (header)) == NULL) {
  79. error (0, "get_cookies: No value in (%s)", octstr_get_cstr(header));
  80. continue;
  81. }
  83. /* Parse the received cookie */
  84. if ((cookie = parse_cookie(value)) != NULL) {
  86. /* Check to see if this cookie is already present */
  87. if (have_cookie(sm->cookies, cookie) == 1) {
  88. debug("wap.wsp.http", 0, "parse_cookie: Cookie present");
  89.       cookie_destroy(cookie);
  90. continue;
  91. } else {
  92. add_cookie_to_cache(sm, cookie);
  93. debug("wap.wsp.http", 0, "get_cookies: Added (%s)", 
  94.   octstr_get_cstr(cookie -> name));
  95. }
  96. }
  97. }
  98. }
  100. debug("wap.wsp.http", 0, "get_cookies: End");
  101. return 0;
  102. }
  105. int set_cookies(List *headers, WSPMachine *sm)
  106. {
  107. Cookie *value = NULL;
  108. Octstr *cookie = NULL;
  109. long pos = 0;
  111. if (sm->cookies == NULL)
  112. sm->cookies = list_create();
  114. if (headers == NULL || sm == NULL) {
  115. error (0, "set_cookies: Null argument(s) - no headers, WSPMachine or both");
  116. return -1;
  117. }
  119. /* Expire cookies that have timed out */
  120. expire_cookies(sm->cookies);
  122. /* Walk through the cookie cache, adding the cookie to the request headers */
  123. if (list_len (sm->cookies) > 0) {
  124. debug("wap.wsp.http", 0, "set_cookies: Cookies in cache");
  126. for (pos = 0; pos < list_len(sm->cookies); pos++) {
  127. value = list_get(sm->cookies, pos);
  129. cookie = octstr_create("Cookie: ");
  130. octstr_append(cookie, value->version);
  131. octstr_append(cookie, value->name);
  132. octstr_append_char(cookie, '=');
  133. octstr_append(cookie, value->value);
  135. if (value->path) {
  136. octstr_append_char(cookie, ';');
  137. octstr_append(cookie, value->path);
  138. }
  139. if (value->domain) {
  140. octstr_append_char(cookie, ';');
  141. octstr_append(cookie, value->domain);
  142. }
  144. list_append(headers, cookie);
  145. debug("wap.wsp.http", 0, "set_cookies: Added (%s)", octstr_get_cstr (cookie));
  146. }
  147. } else
  148. debug("wap.wsp.http", 0, "set_cookies: No cookies in cache");
  150. return 0;
  151. }
  153. /*
  154.  * Private interface functions
  155.  */
  157. /*
  158.  * Function: get_header_value
  159.  *
  160.  * Description: Gets the header value as an Octstr.
  161.  */
  163. static Octstr *get_header_value(Octstr *header) 
  164. {
  165. Octstr *h = NULL;
  166. long colon = -1;
  168. if (header == NULL) {
  169. error(0, "get_header_value: NULL argument");
  170. return NULL;
  171. }
  173. octstr_strip_blanks(header);
  174. colon = octstr_search_char(header, ':', 0);
  175. if (colon == -1) {
  176. error(0, "get_header_value: Malformed header (%s)", octstr_get_cstr (header));
  177. return NULL;
  178. } else {
  179. h = octstr_copy(header, colon + 1, octstr_len(header));
  180. octstr_strip_blanks(h);
  181. }
  183. debug("wap.wsp.http", 0, "get_header_value: Value (%s)", octstr_get_cstr (h));
  184. return h;
  185. }
  187. /*
  188.  * Function: parse_cookie
  189.  *
  190.  * Description: Parses the received cookie and rewrites it for sending.
  191.  */
  193. static Cookie *parse_cookie(Octstr *cookiestr)
  194. {
  195. char *v = NULL;
  196. char *p = NULL;
  197. int delta = 0;
  198. Cookie *c = NULL;
  199. Octstr **f = NULL;
  201. if (cookiestr == NULL) {
  202. error(0, "parse_cookie: NULL argument");
  203. return NULL;
  204. }
  206. v = gw_strdup(octstr_get_cstr (cookiestr));
  207. p = strtok(v, ";");
  209. c = cookie_create(); /* Never returns NULL */
  211. while (p != NULL) {
  212. while (isspace((int)*p)) p++; /* Skip leading whitespace */
  214. if (strncasecmp("version", p, 7) == 0)
  215. f = &c -> version;
  216. else if (strncasecmp("path", p, 4) == 0)
  217. f = &c -> path;
  218. else if (strncasecmp("domain", p, 6) == 0)
  219. f = &c -> domain;
  220. else if (strncasecmp("max-age", p, 7) == 0) {
  221. c -> max_age = atol(strrchr (p, '=') + 1);
  222. p = strtok(NULL, ";");
  223. continue;
  224. } 
  225.         else if (strncasecmp("expires", p, 7) == 0) {
  226. delta = parse_http_date(p);
  227. if (delta != -1) 
  228.                 c->max_age = delta;
  229. p = strtok(NULL, ";");
  230. continue;
  231. }
  232. else if (strncasecmp("comment", p, 7) == 0 || strncasecmp("secure", p, 6) == 0) {
  233. p = strtok(NULL, ";");
  234. continue;
  235. }
  236. else { /* Name value pair - this should be first */
  237. char *equals = NULL;
  239. if ((equals = strrchr(p, '=')) != NULL) {
  240. *equals = '';
  242. c->name = octstr_create(p);
  243. c->value = octstr_create(equals + 1);
  244. } else {
  245. error(0, "parse_cookie: Bad name=value cookie component (%s)", p);
  246. cookie_destroy(c);
  247. return NULL;
  248. }
  249. p = strtok(NULL, ";");
  250. continue;
  251. }
  253. if (*f != NULL) { /* Undefined behaviour - 4.2.2 */
  254. error(0, "parse_cookie: Duplicate cookie field (%s), discarding", p);
  255. p = strtok(NULL, ";");
  256. continue;
  257. }
  259. *f = octstr_create("$");
  260. octstr_append_cstr(*f, p);
  261. p = strtok(NULL, ";");
  262. }
  264. /* Process version - 4.3.4 */
  266. if (c->version == NULL) {
  267. c->version = octstr_create("");
  268. octstr_append_cstr(c->version, "$Version="0";");
  269. }
  271. gw_free (v);
  272. return c;
  273. }
  275. /*
  276.  * Function: add_cookie_to_cache
  277.  *
  278.  * Description: Adds the cookie to the WSPMachine cookie cache.
  279.  */
  281. static void add_cookie_to_cache(const WSPMachine *sm, Cookie *value)
  282. {
  283. gw_assert(sm != NULL);
  284. gw_assert(sm -> cookies != NULL);
  285. gw_assert(value != NULL);
  287. list_append(sm -> cookies, value);
  289. return;
  290. }
  292. /*
  293.  * Function: have_cookie
  294.  *
  295.  * Description: Checks to see if the cookie is present in the list.
  296.  */
  298. static int have_cookie(List *cookies, Cookie *cookie)
  299. {
  300. Cookie *value = NULL;
  301. long pos = 0;
  303. if (cookies == NULL || cookie == NULL) {
  304. error(0, "have_cookie: Null argument(s) - no Cookie list, Cookie or both");
  305. return 0;
  306. }
  308. /* Walk through the cookie cache, comparing cookie */
  310. while (pos < list_len(cookies)) {
  311. value = list_get(cookies, pos);
  313. /* octstr_compare() now only returns 0 on an exact match or if both args are 0 */
  315. debug ("wap.wsp.http", 0, "have_cookie: Comparing name (%s:%s), path (%s:%s), domain (%s:%s)",
  316.    cookie->name == NULL ? "NULL" : octstr_get_cstr(cookie -> name), 
  317.    value->name == NULL ? "NULL" : octstr_get_cstr(value -> name),
  318.    cookie->path == NULL ? "NULL" : octstr_get_cstr(cookie -> path), 
  319.    value->path == NULL ? "NULL" : octstr_get_cstr(value -> path),
  320.    cookie->domain == NULL ? "NULL" : octstr_get_cstr(cookie -> domain), 
  321.    value->domain == NULL ? "NULL" : octstr_get_cstr(value -> domain));
  323. /* Match on no value or value and value equality for name, path and domain */
  325. if ((value->name == NULL || 
  326. ((value->name != NULL) && octstr_compare(value->name, cookie->name) == 0)) &&
  327. (value->path == NULL ||
  328. ((value->path != NULL) && octstr_compare(value->path, cookie->path) == 0)) &&
  329. ((value->domain == NULL) ||
  330. ((value->domain != NULL) && octstr_compare(value->domain, cookie->domain) == 0))) {
  332. /* We have a match according to 4.3.3 - discard the old one */
  334. cookie_destroy(value);
  335. list_delete(cookies, pos, 1);
  337. /* Discard the new cookie also if max-age is 0 - set if expiry date is up */
  339. if (cookie->max_age == 0) {
  340. debug("wap.wsp.http", 0, "have_cookie: Discarding expired cookie (%s)",
  341.       octstr_get_cstr(cookie->name));
  342. return 1;
  343. }
  345. debug("wap.wsp.http", 0, "have_cookie: Updating cached cookie (%s)", 
  346.                   octstr_get_cstr (cookie->name));
  347. break;
  348. } else
  349. pos++;
  350. }
  352. return 0;
  353. }
  355. /*
  356.  * Function: expire_cookies
  357.  *
  358.  * Description: Walks thru the cookie list and checking for expired cookies.
  359.  */
  361. static void expire_cookies(List *cookies)
  362. {
  363. Cookie *value = NULL;
  364. time_t now = 0;
  365. long pos = 0;
  367. if (cookies == NULL) {
  368. error(0, "expire_cookies: Null argument(s) - no Cookie list");
  369. return;
  370. }
  372. /* Walk through the cookie cache */
  374. time(&now);
  376. if (list_len (cookies) > 0) {
  377. debug("wap.wsp.http", 0, "expire_cookies: Cookies in cache");
  378. for (pos = 0; pos < list_len(cookies); pos++) {
  379. value = list_get(cookies, pos);
  380. gw_assert(value != NULL);
  382. if (value->max_age != -1) { /* Interesting value */
  383. if (value->max_age + value->birth < now) {
  384. debug("wap.wsp.http", 0, "expire_cookies: Expired cookie (%s)",
  385.   octstr_get_cstr(value->name));
  386. cookie_destroy(value);
  387. list_delete(cookies, pos, 1);
  388. }
  389. }
  390. }
  391. } else
  392. debug("wap.wsp.http", 0, "expire_cookies: No cookies in cache");
  394. return;
  395. }
  397. static void cookie_destroy (void *p)
  398. {
  399. Cookie *cookie;
  401. if (p == NULL) 
  402.         return;
  403. cookie = p;
  405. octstr_destroy(cookie->name);
  406. octstr_destroy(cookie->value);
  407. octstr_destroy(cookie->version);
  408. octstr_destroy(cookie->domain);
  409. octstr_destroy(cookie->path);
  411. gw_free(cookie);
  412. debug("wap.wsp.http", 0, "cookie_destroy: Destroyed cookie");
  413. return;
  414. }
  416. /*
  417.  * Function: parse_http_date
  418.  *
  419.  * Description: Parses an HTTP date format as used by the Expires: header. See RFC 2616
  420.  * section 3.3.1 for more information.
  421.  * HTTP applications have historically allowed three different formats
  422.  * for the representation of date/time stamps:
  423.  *
  424.  *    Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
  425.  *    Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
  426.  *    Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
  427.  *
  428.  * The first format is preferred as an Internet standard and represents
  429.  * a fixed-length subset of that defined by RFC 1123 [8] (an update to
  430.  * RFC 822 [9]). The second format is in common use, but is based on the
  431.  * obsolete RFC 850 [12] date format and lacks a four-digit year.
  432.  * HTTP/1.1 clients and servers that parse the date value MUST accept
  433.  * all three formats (for compatibility with HTTP/1.0), though they MUST
  434.  * only generate the RFC 1123 format for representing HTTP-date values
  435.  * in header fields.
  436.  *
  437.  * Returns: -1 on success, max-age sematic value on success.
  438.  */
  440. static const char* months[] = {
  441. "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  442.     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", NULL
  443. };
  445. static int month_index(const char *s)
  446. {
  447. const char **p = &months[0];
  448. int i = 0;
  450. while (*p != NULL) {
  451. if (strcmp(s, *p) == 0)
  452. return i;
  453. p++, i++;
  454. }
  456. return -1;
  457. }
  459. static int parse_http_date(const char *expires)
  460. {
  461. struct tm ti;
  462. char *p = NULL;
  463. char *date = NULL;
  464. char month[MAX_HTTP_DATE_LENGTH];
  465. time_t rv;
  466. time_t now;
  468. memset(&ti, 0, sizeof(struct tm));
  470. /* Break up the Expires: header */
  472. if (!(date = strchr(expires, '='))) {
  473. error(0, "parse_http_date: Bogus expires type=value header (%s)", expires);
  474. return -1;
  475. } else {
  476. date++;
  477. while (isspace((int)*date))
  478. ++date;
  479. }
  481. /* Onto the date value */
  483. if (!(p = strchr (date,' '))) {
  484. error(0, "parse_http_date: Bogus date string (%s)", date);
  485. return -1;
  486. } else
  487. while (isspace((int)*p))
  488. ++p;
  490. if (MAX_HTTP_DATE_LENGTH < strlen(p)) {
  491. error(0, "parse_http_date: %s blows length limit (%d)", date, MAX_HTTP_DATE_LENGTH);
  492. return -1;
  493. }
  495. if (isalpha((int)*p)) {
  496. /* ctime */
  497. sscanf(p, (strstr(p, "DST") ? "%s %d %d:%d:%d %*s %d" : "%s %d %d:%d:%d %d"),
  498.    month, &ti.tm_mday, &ti.tm_hour, &ti.tm_min,
  499.    &ti.tm_sec, &ti.tm_year);
  500. ti.tm_year -= 1900;
  502. } else if (p[2] == '-') {
  503. /* RFC 850 (normal HTTP) */
  505. char  buf[MAX_HTTP_DATE_LENGTH];
  507. sscanf(p, "%s %d:%d:%d", buf, &ti.tm_hour, &ti.tm_min, &ti.tm_sec);
  508. buf[2] = '';
  509. ti.tm_mday = atoi(buf);
  510. buf[6] = '';
  512. strcpy(month, &buf[3]);
  513. ti.tm_year = atoi(&buf[7]);
  515. /* Prevent wraparound from ambiguity */
  517. if (ti.tm_year < 70) {
  518. ti.tm_year += 100;
  519. } else if (ti.tm_year > 1900) {
  520. ti.tm_year -= 1900;
  521. }
  522. } else {
  523. /* RFC 822 */
  525. sscanf(p,"%d %s %d %d:%d:%d",&ti.tm_mday, month, &ti.tm_year,
  526.    &ti.tm_hour, &ti.tm_min, &ti.tm_sec);
  528. /* 
  529.          * since tm_year is years since 1900 and the year we parsed
  530.  * is absolute, we need to subtract 1900 years from it
  531.  */
  533. ti.tm_year -= 1900;
  534. }
  536. ti.tm_mon = month_index(month);
  537. if (ti.tm_mon == -1) {
  538. error(0, "parse_http_date () failed on bad month value (%s)", month);
  539. return -1;
  540. }
  542. ti.tm_isdst = -1;
  544. rv = mktime(&ti);
  545. if (ti.tm_isdst)
  546. rv -= 3600;
  548. if (rv == -1) {
  549. error(0, "parse_http_date(): mktime() was unable to resolve date/time: %s", 
  550.   asctime (&ti));
  551. return -1;
  552. }
  554. debug("parse_http_date", 0, "Parsed date (%s) as: %s", date, asctime(&ti));
  556. /* 
  557.      * If rv is valid, it should be some time in the (near) future. Normalise this to
  558.  * a max-age semantic so we can use the same expiry mechanism 
  559.  */
  561. now = time(NULL);
  563. if (rv - now < 0) {
  565. /* This is bad - set the delta to 0 so we expire next time around */
  567. error(0, "parse_http_date () Expiry time (%s) (delta=%ld) is in the past !", 
  568.   asctime (&ti), rv-now);
  569. return 0;
  570. }
  572. return rv - now;
  573. }
  574.