/* * File: cookies.c * * Copyright 2001 Lars Clausen   <lrclause@cs.uiuc.edu> *                J鰎gen Viksell <jorgen.viksell@telia.com> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. *//* Handling of cookies takes place here. * This implementation aims to follow RFC 2965: * http://www.cis.ohio-state.edu/cs/Services/rfc/rfc-text/rfc2965.txt */#ifndef DISABLE_COOKIES#include <sys/types.h>#include <sys/stat.h>#include <sys/file.h>#include <fcntl.h>#include <stdlib.h>#include <stdio.h>#include <time.h>       /* for time() and time_t */#include <ctype.h>#include "msg.h"#include "IO/Url.h"#include "misc.h"#include "list.h"#include "cookies.h"#define DEBUG_LEVEL 8#include "debug.h"/* The maximum length of a line in the cookie file */#define LINE_MAXLEN 4096typedef enum {   COOKIE_ACCEPT,   COOKIE_ACCEPT_SESSION,   COOKIE_DENY} CookieControlAction;typedef struct {   CookieControlAction action;   char *domain;} CookieControl;typedef struct {   char *name;   char *value;   char *domain;   char *path;   time_t expires_at;   guint version;   char *comment;   char *comment_url;   gboolean secure;   gboolean session_only;   GList *ports;} CookieData_t;/* Hashtable indexed by domain, each value is a set of cookies for * that domain. */static GHashTable *cookies;/* Variables for access control */static CookieControl *ccontrol = NULL;static int num_ccontrol = 0;static int num_ccontrol_max = 1;static CookieControlAction default_action = COOKIE_DENY;static gboolean disabled;static FILE *file_stream;static FILE *Cookies_fopen(const char *file, gchar *init_str);static CookieControlAction Cookies_control_check(const DilloUrl *url);static CookieControlAction Cookies_control_check_domain(const char *domain);static int Cookie_control_init(void);static void Cookies_parse_ports(const DilloUrl *set_url, CookieData_t *cookie,                                const char *port_str);static char *Cookies_build_ports_str(CookieData_t *cookie);static char *Cookies_strip_path(const char *path);static void Cookies_add_cookie(CookieData_t *cookie);static void Cookies_remove_cookie(CookieData_t *cookie);static gint Cookies_equals(gconstpointer a, gconstpointer b);/* * Return a file pointer. If the file doesn't exist, try to create it, * with the optional 'init_str' as its content. */static FILE *Cookies_fopen(const char *filename, gchar *init_str){   FILE *F_in;   int fd;   if ((F_in = fopen(filename, "r+")) == NULL) {      /* Create the file */      fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);      if (fd != -1) {         if (init_str)            write(fd, init_str, strlen(init_str));         close(fd);         DEBUG_MSG(10, "Cookies: Created file: %s\n", filename);         F_in = Cookies_fopen(filename, NULL);      } else {         DEBUG_MSG(10, "Cookies: Could not create file: %s!\n", filename);      }   }   /* set close on exec */   fcntl(fileno(F_in), F_SETFD, FD_CLOEXEC | fcntl(fileno(F_in), F_GETFD));   return F_in;}static void Cookies_free_cookie(CookieData_t *cookie){   g_free(cookie->name);   g_free(cookie->value);   g_free(cookie->domain);   g_free(cookie->path);   g_free(cookie->comment);   g_free(cookie->comment_url);   g_list_free(cookie->ports);   g_free(cookie);}/* * Initialize the cookies module * (The 'disabled' variable is writable only within a_Cookies_init) */void a_Cookies_init(){   CookieData_t *cookie;   char *filename;   char line[LINE_MAXLEN];#ifndef HAVE_LOCKF   struct flock lck;#endif   /* Default setting */   disabled = TRUE;   /* Read and parse the cookie control file (cookiesrc) */   if (Cookie_control_init() != 0) {      DEBUG_MSG(10, "Disabling cookies.\n");      return;   }   /* Get a stream for the cookies file */   filename = a_Misc_prepend_user_home(".dillo/cookies");   file_stream = Cookies_fopen(filename, NULL);   g_free(filename);   if (!file_stream) {      DEBUG_MSG(10, "ERROR: Can't open ~/.dillo/cookies, disabling cookies\n");      return;   }   /* Try to get a lock from the file descriptor */#ifdef HAVE_LOCKF   disabled = (lockf(fileno(file_stream), F_TLOCK, 0) == -1);#else /* POSIX lock */   lck.l_start = 0; /* start at beginning of file */   lck.l_len = 0;  /* lock entire file */   lck.l_type = F_WRLCK;   lck.l_whence = SEEK_SET;  /* absolute offset */   disabled = (fcntl(fileno(file_stream), F_SETLK, &lck) == -1);#endif   if (disabled) {      DEBUG_MSG(10, "The cookies file has a file lock:\n"                    "  disabling cookies in this dillo!\n");      fclose(file_stream);      return;   }   DEBUG_MSG(10, "Enabling cookies as from cookiesrc...\n");   cookies = g_hash_table_new(g_str_hash, g_str_equal);   /* Get all lines in the file */   while (!feof(file_stream)) {      line[0] = '\0';      fgets(line, LINE_MAXLEN, file_stream);      /* Remove leading and trailing whitespaces */      g_strstrip(line);      if (line[0] != '\0') {         /* Would use g_strsplit, but it doesn't give empty trailing pieces.          */         /* Split the row into pieces using a tab as the delimiter.          * pieces[0] The version this cookie was set as (0 / 1)          * pieces[1] The domain name          * pieces[2] A comma separated list of accepted ports          * pieces[3] The path          * pieces[4] Is the cookie unsecure or secure (0 / 1)          * pieces[5] Timestamp of expire date          * pieces[6] Name of the cookie          * pieces[7] Value of the cookie          * pieces[8] Comment          * pieces[9] Comment url          */         CookieControlAction action;         char *piece;         char *line_marker = line;         cookie = g_new0(CookieData_t, 1);         cookie->session_only = FALSE;         piece = d_strsep(&line_marker, "\t");         if (piece != NULL)            cookie->version = strtol(piece, NULL, 10);         cookie->domain  = g_strdup(d_strsep(&line_marker, "\t"));         Cookies_parse_ports(NULL, cookie, d_strsep(&line_marker, "\t"));         cookie->path = g_strdup(d_strsep(&line_marker, "\t"));         piece = d_strsep(&line_marker, "\t");         if (piece != NULL && piece[0] == '1')            cookie->secure = TRUE;         piece = d_strsep(&line_marker, "\t");         if (piece != NULL)            cookie->expires_at = (time_t) strtol(piece, NULL, 10);         cookie->name = g_strdup(d_strsep(&line_marker, "\t"));         cookie->value = g_strdup(d_strsep(&line_marker, "\t"));         cookie->comment = g_strdup(d_strsep(&line_marker, "\t"));         cookie->comment_url = g_strdup(d_strsep(&line_marker, "\t"));         if (!cookie->domain || cookie->domain[0] == '\0' ||             !cookie->path || cookie->path[0] != '/' ||             !cookie->name || cookie->name[0] == '\0' ||             !cookie->value) {            DEBUG_MSG(8, "Malformed line in cookies file!\n");            Cookies_free_cookie(cookie);            continue;         }         action = Cookies_control_check_domain(cookie->domain);         if (action == COOKIE_DENY) {            Cookies_free_cookie(cookie);            continue;         } else if (action == COOKIE_ACCEPT_SESSION) {            cookie->session_only = TRUE;         }         /* Save cookie in memory */         Cookies_add_cookie(cookie);      }   }}/* * Save the cookies and remove them from the hash table */static gboolean Cookies_freeall_cb(gpointer key,                                   gpointer value,                                   gpointer data){   CookieData_t *cookie;   GList *domain_cookies = value;   char *ports_str;   for (; domain_cookies; domain_cookies = g_list_next(domain_cookies)) {      cookie = domain_cookies->data;      if (!cookie->session_only) {         ports_str = Cookies_build_ports_str(cookie);         fprintf(file_stream, "%d\t%s\t%s\t%s\t%d\t%ld\t%s\t%s\t%s\t%s\n",                 cookie->version,                 cookie->domain,                 ports_str,                 cookie->path,                 cookie->secure ? 1 : 0,                 (long)cookie->expires_at,                 cookie->name,                 cookie->value,                 (cookie->comment) ? cookie->comment : "",                 (cookie->comment_url) ? cookie->comment_url : "");         g_free(ports_str);      }      Cookies_free_cookie(cookie);   }   g_list_free(value);   g_free(key);   /* Return TRUE to tell GLIB to free this key from the hash table */   return TRUE;}/* * Flush cookies to disk and free all the memory allocated. */void a_Cookies_freeall(){   int fd;#ifndef HAVE_LOCKF   struct flock lck;#endif   if (disabled)      return;   rewind(file_stream);   fd = fileno(file_stream);   ftruncate(fd, 0);   g_hash_table_foreach_remove(cookies, Cookies_freeall_cb, NULL);#ifdef HAVE_LOCKF   lockf(fd, F_ULOCK, 0);#else  /* POSIX file lock */   lck.l_start = 0; /* start at beginning of file */   lck.l_len = 0;  /* lock entire file */   lck.l_type = F_UNLCK;   lck.l_whence = SEEK_SET;  /* absolute offset */   fcntl(fileno(file_stream), F_SETLKW, &lck);#endif   fclose(file_stream);}static char *months[] ={ "",  "Jan", "Feb", "Mar",  "Apr", "May", "Jun",  "Jul", "Aug", "Sep",  "Oct", "Nov", "Dec"};/* * Take a months name and return a number between 1-12. * E.g. 'April' -> 4 */static int Cookies_get_month(const char *month_name){   int i;   for (i = 1; i <= 12; i++) {      if (!g_strncasecmp(months[i], month_name, 3))         return i;   }   return 0;}/* * Return a local timestamp from a GMT date string * Accept: RFC-1123 | RFC-850 | ANSI asctime * (return 0 on malformed date string syntax) */static time_t Cookies_create_timestamp(const char *expires){   time_t ret;   int day, month, year, hour, minutes, seconds;   gchar *cp;   gchar *E_msg =      "Cookies: Expire date is malformed!\n"      " (should be RFC-1123 | RFC-850 | ANSI asctime)\n"      " Ignoring cookie...\n";   if (!(cp = strchr(expires, ',')) && strlen(expires) == 24) {      /* Looks like ANSI asctime format... */      cp = (gchar *)expires;      day = strtol(cp + 8, NULL, 10);       /* day */      month = Cookies_get_month(cp + 4);    /* month */      year = strtol(cp + 20, NULL, 10);     /* year */      hour = strtol(cp + 11, NULL, 10);     /* hour */      minutes = strtol(cp + 14, NULL, 10);  /* minutes */      seconds = strtol(cp + 17, NULL, 10);  /* seconds */   } else if (cp && ((cp - expires == 3 && strlen(cp) == 26) ||                     (cp - expires > 5  && strlen(cp) == 24))) {      /* RFC-1123 | RFC-850 format */      day = strtol(cp + 2, NULL, 10);      month = Cookies_get_month(cp + 5);      year = strtol(cp + 9, &cp, 10);      /* todo: tricky, because two digits for year IS ambiguous! */      year += (year < 70) ? 2000 : ((year < 100) ? 1900 : 0);      hour = strtol(cp + 1, NULL, 10);      minutes = strtol(cp + 4, NULL, 10);      seconds = strtol(cp + 7, NULL, 10);   } else {      DEBUG_MSG(5, E_msg);      return (time_t) 0;   }   /* Error checks  --this may be overkill */   if (!(day > 0 && day < 32 && month > 0 && month && year > 1970 &&         hour >= 0 && hour < 24 && minutes >= 0 && minutes < 60 &&         seconds >= 0 && seconds < 60)) {      DEBUG_MSG(5, E_msg);