privoxy-log-parser: Update Privoxy man page reference now that the section is 8
[privoxy.git] / client-tags.c
1 /*********************************************************************
2  *
3  * File        :  $Source: /cvsroot/ijbswa/current/client-tags.c,v $
4  *
5  * Purpose     :  Functions related to client-specific tags.
6  *
7  * Copyright   :  Copyright (C) 2016-2017 Fabian Keil <fk@fabiankeil.de>
8  *
9  *                This program is free software; you can redistribute it
10  *                and/or modify it under the terms of the GNU General
11  *                Public License as published by the Free Software
12  *                Foundation; either version 2 of the License, or (at
13  *                your option) any later version.
14  *
15  *                This program is distributed in the hope that it will
16  *                be useful, but WITHOUT ANY WARRANTY; without even the
17  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
18  *                PARTICULAR PURPOSE.  See the GNU General Public
19  *                License for more details.
20  *
21  *                The GNU General Public License should be included with
22  *                this file.  If not, you can view it at
23  *                http://www.gnu.org/copyleft/gpl.html
24  *                or write to the Free Software Foundation, Inc., 59
25  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
26  *
27  **********************************************************************/
28
29 #include "config.h"
30
31 #ifdef FEATURE_CLIENT_TAGS
32
33 #include <stdio.h>
34 #include <sys/types.h>
35 #include <stdlib.h>
36 #include <ctype.h>
37 #include <string.h>
38 #include <assert.h>
39
40 #include "project.h"
41 #include "list.h"
42 #include "jcc.h"
43 #include "miscutil.h"
44 #include "errlog.h"
45 #include "parsers.h"
46
47 struct client_specific_tag
48 {
49    char *name;
50
51    time_t end_of_life;
52
53    struct client_specific_tag *next;
54    struct client_specific_tag *prev;
55 };
56
57 /**
58  * This struct represents tags that have been requested by clients
59  */
60 struct requested_tags
61 {
62    char *client; /**< The IP address of the client that requested the tag */
63
64    /**< List of tags the client requested .... */
65    struct client_specific_tag *tags;
66
67    struct requested_tags *next;
68    struct requested_tags *prev;
69 };
70
71 struct requested_tags *requested_tags;
72 static void remove_tag_for_client(const char *client_address, const char *tag);
73
74 /*********************************************************************
75  *
76  * Function    :  validate_tag_list
77  *
78  * Description :  Validates the given tag list
79  *
80  * Parameters  :
81  *          1  :  enabled_tags = The tags to validate
82  *
83  * Returns     :  void
84  *
85  *********************************************************************/
86 static void validate_tag_list(struct client_specific_tag *enabled_tags)
87 {
88    while (enabled_tags != NULL)
89    {
90       if (enabled_tags->name == NULL)
91       {
92          assert(enabled_tags->name != NULL);
93          log_error(LOG_LEVEL_FATAL, "validate_tag_list(): Tag without name detected");
94       }
95       if (enabled_tags->next != NULL)
96       {
97          if (enabled_tags->next->prev != enabled_tags)
98          {
99             assert(enabled_tags->next->prev == enabled_tags);
100             log_error(LOG_LEVEL_FATAL, "validate_tag_list(): Invalid backlink detected");
101          }
102       }
103       enabled_tags = enabled_tags->next;
104    }
105 }
106
107 /*********************************************************************
108  *
109  * Function    :  validate_requested_tags
110  *
111  * Description :  Validates the requested_tags list
112  *
113  * Parameters  : N/A
114  *
115  * Returns     :  void
116  *
117  *********************************************************************/
118 static jb_err validate_requested_tags()
119 {
120    struct requested_tags *requested_tag;
121
122    for (requested_tag = requested_tags; requested_tag != NULL;
123         requested_tag = requested_tag->next)
124    {
125       if (requested_tag->client == NULL)
126       {
127          assert(requested_tag->client != NULL);
128          log_error(LOG_LEVEL_FATAL, "validate_tag_list(): Client not registered");
129       }
130       validate_tag_list(requested_tag->tags);
131       if (requested_tag->next != NULL)
132       {
133          if (requested_tag->next->prev != requested_tag)
134          {
135             assert(requested_tag->next->prev == requested_tag);
136             log_error(LOG_LEVEL_FATAL, "validate_requested_tags(): Invalid backlink detected");
137          }
138       }
139    }
140
141    return TRUE;
142 }
143
144
145 /*********************************************************************
146  *
147  * Function    :  get_client_specific_tag
148  *
149  * Description :  Returns the data for a client-specific-tag specified
150  *                by name.
151  *
152  * Parameters  :
153  *          1  :  tag_list = The tag list to check
154  *          2  :  name =     The tag name to look up
155  *
156  * Returns     :  Pointer to tag structure or NULL on error.
157  *
158  *********************************************************************/
159 static struct client_tag_spec *get_client_specific_tag(
160    struct client_tag_spec *tag_list, const char *name)
161 {
162    struct client_tag_spec *tag;
163
164    for (tag = tag_list; tag != NULL; tag = tag->next)
165    {
166       if (tag->name != NULL && !strcmp(tag->name, name))
167       {
168          return tag;
169       }
170    }
171
172    log_error(LOG_LEVEL_ERROR, "No such tag: '%s'", name);
173
174    return NULL;
175
176 }
177
178
179 /*********************************************************************
180  *
181  * Function    :  get_tags_for_client
182  *
183  * Description :  Returns the list of tags the client opted-in.
184  *
185  * Parameters  :
186  *          1  :  client_address = Address of the client
187  *
188  * Returns     :  Pointer to tag structure or NULL on error.
189  *
190  *********************************************************************/
191 static struct client_specific_tag *get_tags_for_client(const char *client_address)
192 {
193    struct requested_tags *requested_tag;
194
195    for (requested_tag = requested_tags; requested_tag != NULL;
196         requested_tag = requested_tag->next)
197    {
198       if (!strcmp(requested_tag->client, client_address))
199       {
200          return requested_tag->tags;
201       }
202    }
203
204    return NULL;
205 }
206
207
208 /*********************************************************************
209  *
210  * Function    :  get_tag_list_for_client
211  *
212  * Description :  Provides a list of tag names the client opted-in.
213  *                Other tag attributes are not part of the list.
214  *
215  * Parameters  :
216  *          1  :  tag_list = The list to fill in.
217  *          2  :  client_address = Address of the client
218  *
219  * Returns     :  Pointer to tag list.
220  *
221  *********************************************************************/
222 void get_tag_list_for_client(struct list *tag_list,
223                              const char *client_address)
224 {
225    struct client_specific_tag *enabled_tags;
226    const time_t now = time(NULL);
227
228    privoxy_mutex_lock(&client_tags_mutex);
229
230    enabled_tags = get_tags_for_client(client_address);
231    while (enabled_tags != NULL)
232    {
233       if (enabled_tags->end_of_life && (enabled_tags->end_of_life < now))
234       {
235          struct client_specific_tag *next_tag = enabled_tags->next;
236          log_error(LOG_LEVEL_TAGGING,
237             "Tag '%s' for client %s expired %ld seconds ago. Deleting it.",
238             enabled_tags->name, client_address,
239             (now - enabled_tags->end_of_life));
240          remove_tag_for_client(client_address, enabled_tags->name);
241          enabled_tags = next_tag;
242          continue;
243       }
244       else
245       {
246          log_error(LOG_LEVEL_TAGGING, "Enlisting tag '%s' for client %s",
247             enabled_tags->name, client_address);
248          enlist(tag_list, enabled_tags->name);
249       }
250       enabled_tags = enabled_tags->next;
251    }
252
253    privoxy_mutex_unlock(&client_tags_mutex);
254 }
255
256
257 /*********************************************************************
258  *
259  * Function    :  get_next_tag_timeout_for_client
260  *
261  * Description :  Figures out when the next temporarily enabled tag
262  *                for the client will have timed out.
263  *
264  * Parameters  :
265  *          1  :  client_address = Address of the client
266  *
267  * Returns     :  Lowest timeout in seconds
268  *
269  *********************************************************************/
270 time_t get_next_tag_timeout_for_client(const char *client_address)
271 {
272    struct client_specific_tag *enabled_tags;
273    time_t next_timeout = 0;
274    const time_t now = time(NULL);
275
276    privoxy_mutex_lock(&client_tags_mutex);
277
278    enabled_tags = get_tags_for_client(client_address);
279    while (enabled_tags != NULL)
280    {
281       log_error(LOG_LEVEL_TAGGING,
282          "Evaluating tag '%s' for client %s. End of life %ld",
283          enabled_tags->name, client_address, enabled_tags->end_of_life);
284       if (enabled_tags->end_of_life)
285       {
286           time_t time_left = enabled_tags->end_of_life - now;
287           /* Add a second to make sure the tag will have expired */
288           time_left++;
289           log_error(LOG_LEVEL_CGI, "%ld > %ld?", next_timeout, time_left);
290           if (next_timeout == 0 || next_timeout > time_left)
291           {
292              next_timeout = time_left;
293           }
294        }
295        enabled_tags = enabled_tags->next;
296    }
297
298    privoxy_mutex_unlock(&client_tags_mutex);
299
300    log_error(LOG_LEVEL_CGI, "Next timeout in %ld seconds", next_timeout);
301
302    return next_timeout;
303
304 }
305
306
307 /*********************************************************************
308  *
309  * Function    :  create_client_specific_tag
310  *
311  * Description :  Allocates memory for a client specific tag
312  *                and populates it.
313  *
314  * Parameters  :
315  *          1  :  name = The name of the tag to create.
316  *          2  :  time_to_live = 0, or the number of seconds
317  *                               the tag remains activated.
318  *
319  * Returns     :  Pointer to populated tag
320  *
321  *********************************************************************/
322 static struct client_specific_tag *create_client_specific_tag(const char *name,
323    const time_t time_to_live)
324 {
325    struct client_specific_tag *tag;
326
327    tag = zalloc_or_die(sizeof(struct client_specific_tag));
328    tag->name = strdup_or_die(name);
329    tag->end_of_life = time_to_live ? (time(NULL) + time_to_live) : 0;
330
331    return tag;
332
333 }
334
335 /*********************************************************************
336  *
337  * Function    :  add_tag_for_client
338  *
339  * Description :  Adds the tag for the client.
340  *
341  * Parameters  :
342  *          1  :  client_address = Address of the client
343  *          2  :  tag = The tag to add.
344  *          3  :  time_to_live = 0, or the number of seconds
345  *                               the tag remains activated.
346  *
347  * Returns     :  void
348  *
349  *********************************************************************/
350 static void add_tag_for_client(const char *client_address,
351    const char *tag, const time_t time_to_live)
352 {
353    struct requested_tags *clients_with_tags;
354    struct client_specific_tag *enabled_tags;
355
356    validate_requested_tags();
357
358    if (requested_tags == NULL)
359    {
360       /* XXX: Code duplication. */
361       requested_tags = zalloc_or_die(sizeof(struct requested_tags));
362       requested_tags->client = strdup_or_die(client_address);
363       requested_tags->tags = create_client_specific_tag(tag, time_to_live);
364
365       validate_requested_tags();
366       return;
367    }
368    else
369    {
370       clients_with_tags = requested_tags;
371       while (clients_with_tags->next != NULL)
372       {
373          if (!strcmp(clients_with_tags->client, client_address))
374          {
375             break;
376          }
377          clients_with_tags = clients_with_tags->next;
378       }
379       if (strcmp(clients_with_tags->client, client_address))
380       {
381          /* Client does not have tags yet, add new structure */
382          clients_with_tags->next = zalloc_or_die(sizeof(struct requested_tags));
383          clients_with_tags->next->prev = clients_with_tags;
384          clients_with_tags = clients_with_tags->next;
385          clients_with_tags->client = strdup_or_die(client_address);
386          clients_with_tags->tags = create_client_specific_tag(tag, time_to_live);
387
388          validate_requested_tags();
389
390          return;
391       }
392    }
393
394    enabled_tags = clients_with_tags->tags;
395    while (enabled_tags != NULL)
396    {
397       if (enabled_tags->next == NULL)
398       {
399          enabled_tags->next = create_client_specific_tag(tag, time_to_live);
400          enabled_tags->next->prev = enabled_tags;
401          break;
402       }
403       enabled_tags = enabled_tags->next;
404    }
405
406    validate_requested_tags();
407 }
408
409
410 /*********************************************************************
411  *
412  * Function    :  remove_tag_for_client
413  *
414  * Description :  Removes the tag for the client.
415  *
416  * Parameters  :
417  *          1  :  client_address = Address of the client
418  *          2  :  tag = The tag to remove.
419  *
420  * Returns     :  void
421  *
422  *********************************************************************/
423 static void remove_tag_for_client(const char *client_address, const char *tag)
424 {
425    struct requested_tags *clients_with_tags;
426    struct client_specific_tag *enabled_tags;
427
428    validate_requested_tags();
429
430    clients_with_tags = requested_tags;
431    while (clients_with_tags != NULL && clients_with_tags->client != NULL)
432    {
433       if (!strcmp(clients_with_tags->client, client_address))
434       {
435          break;
436       }
437       clients_with_tags = clients_with_tags->next;
438    }
439
440    assert(clients_with_tags != NULL);
441    if (clients_with_tags == NULL)
442    {
443       log_error(LOG_LEVEL_ERROR,
444          "Tried to remove tag %s for tag-less client %s",
445          tag, client_address);
446    }
447    enabled_tags = clients_with_tags->tags;
448    while (enabled_tags != NULL)
449    {
450       if (!strcmp(enabled_tags->name, tag))
451       {
452          if (enabled_tags->next != NULL)
453          {
454             enabled_tags->next->prev = enabled_tags->prev;
455             if (enabled_tags == clients_with_tags->tags)
456             {
457                /* Tag is first in line */
458                clients_with_tags->tags = enabled_tags->next;
459             }
460          }
461          if (enabled_tags->prev != NULL)
462          {
463             /* Tag has preceding tag */
464             enabled_tags->prev->next = enabled_tags->next;
465          }
466          if (enabled_tags->prev == NULL && enabled_tags->next == NULL)
467          {
468             /* Tag is the only one */
469             if (clients_with_tags->next != NULL)
470             {
471                /* Client has following client */
472                clients_with_tags->next->prev = clients_with_tags->prev;
473             }
474             if (clients_with_tags->prev != NULL)
475             {
476                /* Client has preceding client */
477                clients_with_tags->prev->next = clients_with_tags->next;
478             }
479             if (clients_with_tags == requested_tags)
480             {
481                /*
482                 * We're in the process of removing the last tag,
483                 * mark the global list as empty.
484                 */
485                requested_tags = NULL;
486             }
487             freez(clients_with_tags->client);
488             freez(clients_with_tags);
489          }
490          freez(enabled_tags->name);
491          freez(enabled_tags);
492          break;
493       }
494
495       enabled_tags = enabled_tags->next;
496    }
497
498    validate_requested_tags();
499
500 }
501
502
503 /*********************************************************************
504  *
505  * Function    :  client_has_requested_tag
506  *
507  * Description :  Checks whether or not the given client requested
508  *                the tag.
509  *
510  * Parameters  :
511  *          1  :  client_address = Address of the client
512  *          2  :  tag = Tag to check.
513  *
514  * Returns     :  TRUE or FALSE.
515  *
516  *********************************************************************/
517 int client_has_requested_tag(const char *client_address, const char *tag)
518 {
519    struct client_specific_tag *enabled_tags;
520
521    enabled_tags = get_tags_for_client(client_address);
522
523    while (enabled_tags != NULL)
524    {
525       if (!strcmp(enabled_tags->name, tag))
526       {
527          return TRUE;
528       }
529       enabled_tags = enabled_tags->next;
530    }
531
532    return FALSE;
533
534 }
535
536 /*********************************************************************
537  *
538  * Function    :  enable_client_specific_tag
539  *
540  * Description :  Enables a client-specific-tag for the client
541  *
542  * Parameters  :
543  *          1  :  csp = Current client state (buffers, headers, etc...)
544  *          2  :  tag_name = The name of the tag to enable
545  *          3  :  time_to_live = If not 0, the number of seconds the
546  *                               tag should stay enabled.
547  *
548  * Returns     :  JB_ERR_OK on success, JB_ERR_MEMORY or JB_ERR_PARSE.
549  *
550  *********************************************************************/
551 jb_err enable_client_specific_tag(struct client_state *csp,
552    const char *tag_name, const time_t time_to_live)
553 {
554    struct client_tag_spec *tag;
555
556    privoxy_mutex_lock(&client_tags_mutex);
557
558    tag = get_client_specific_tag(csp->config->client_tags, tag_name);
559    if (tag == NULL)
560    {
561       privoxy_mutex_unlock(&client_tags_mutex);
562       return JB_ERR_PARSE;
563    }
564
565    if (client_has_requested_tag(csp->client_address, tag_name))
566    {
567       log_error(LOG_LEVEL_TAGGING,
568          "Tag '%s' already enabled for client '%s'", tag->name, csp->client_address);
569    }
570    else
571    {
572       add_tag_for_client(csp->client_address, tag_name, time_to_live);
573       log_error(LOG_LEVEL_TAGGING,
574          "Tag '%s' enabled for client '%s'. TTL: %ld.",
575          tag->name, csp->client_address, time_to_live);
576    }
577
578    privoxy_mutex_unlock(&client_tags_mutex);
579
580    return JB_ERR_OK;
581
582 }
583
584 /*********************************************************************
585  *
586  * Function    :  disable_client_specific_tag
587  *
588  * Description :  Disables a client-specific-tag for the client
589  *
590  * Parameters  :
591  *          1  :  csp = Current client state (buffers, headers, etc...)
592  *          2  :  tag_name = The name of the tag to disable
593  *
594  * Returns     :  JB_ERR_OK on success, JB_ERR_MEMORY or JB_ERR_PARSE.
595  *
596  *********************************************************************/
597 jb_err disable_client_specific_tag(struct client_state *csp, const char *tag_name)
598 {
599    struct client_tag_spec *tag;
600
601    privoxy_mutex_lock(&client_tags_mutex);
602
603    tag = get_client_specific_tag(csp->config->client_tags, tag_name);
604    if (tag == NULL)
605    {
606       privoxy_mutex_unlock(&client_tags_mutex);
607       return JB_ERR_PARSE;
608    }
609
610    if (client_has_requested_tag(csp->client_address, tag_name))
611    {
612       remove_tag_for_client(csp->client_address, tag_name);
613       log_error(LOG_LEVEL_TAGGING,
614          "Tag '%s' disabled for client '%s'", tag->name, csp->client_address);
615    }
616    else
617    {
618       log_error(LOG_LEVEL_TAGGING,
619          "Tag '%s' currently not set for client '%s'",
620          tag->name, csp->client_address);
621    }
622
623    privoxy_mutex_unlock(&client_tags_mutex);
624    return JB_ERR_OK;
625
626 }
627
628
629 /*********************************************************************
630  *
631  * Function    :  client_tag_match
632  *
633  * Description :  Compare a client tag against a client tag pattern.
634  *
635  * Parameters  :
636  *          1  :  pattern = a TAG pattern
637  *          2  :  tag = Client tag to match
638  *
639  * Returns     :  Nonzero if the tag matches the pattern, else 0.
640  *
641  *********************************************************************/
642 int client_tag_match(const struct pattern_spec *pattern,
643                      const struct list *tags)
644 {
645    struct list_entry *tag;
646
647    if (!(pattern->flags & PATTERN_SPEC_CLIENT_TAG_PATTERN))
648    {
649       /*
650        * It's not a client pattern and thus shouldn't
651        * be matched against client tags.
652        */
653       return 0;
654    }
655
656    assert(tags);
657
658    for (tag = tags->first; tag != NULL; tag = tag->next)
659    {
660       if (0 == regexec(pattern->pattern.tag_regex, tag->str, 0, NULL, 0))
661       {
662          log_error(LOG_LEVEL_TAGGING, "Client tag '%s' matches", tag->str);
663          return 1;
664       }
665    }
666
667    return 0;
668
669 }
670
671
672 /*********************************************************************
673  *
674  * Function    :  set_client_address
675  *
676  * Description :  Sets the client address that will be used to enable,
677  *                disable, or apply client tags.
678  *
679  * Parameters  :
680  *          1  :  csp = Current client state (buffers, headers, etc...)
681  *          2  :  headers = Client headers
682  *
683  * Returns     :  void.
684  *
685  *********************************************************************/
686 void set_client_address(struct client_state *csp, const struct list *headers)
687 {
688    if (csp->config->trust_x_forwarded_for)
689    {
690       const char *client_address;
691
692       client_address = get_header_value(headers, "X-Forwarded-For:");
693       if (client_address != NULL)
694       {
695          csp->client_address = strdup_or_die(client_address);
696          log_error(LOG_LEVEL_HEADER,
697             "Got client address %s from X-Forwarded-For header",
698             csp->client_address);
699       }
700    }
701
702    if (csp->client_address == NULL)
703    {
704       csp->client_address = strdup_or_die(csp->ip_addr_str);
705    }
706 }
707
708 #else
709 #error Compiling client-tags.c without FEATURE_CLIENT_TAGS
710 #endif /* def FEATURE_CLIENT_TAGS */