source/printing/pcap.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    printcap parsing
   4    Copyright (C) Karl Auer 1993-1998
   5
   6    Re-working by Martin Kiff, 1994
   7
   8    Re-written again by Andrew Tridgell
   9
  10    Modified for SVID support by Norm Jacobs, 1997
  11
  12    Modified for CUPS support by Michael Sweet, 1999
  13
  14    This program is free software; you can redistribute it and/or modify
  15    it under the terms of the GNU General Public License as published by
  16    the Free Software Foundation; either version 3 of the License, or
  17    (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22    GNU General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  26 */
  27
  28 /*
  29  *  This module contains code to parse and cache printcap data, possibly
  30  *  in concert with the CUPS/SYSV/AIX-specific code found elsewhere.
  31  *
  32  *  The way this module looks at the printcap file is very simplistic.
  33  *  Only the local printcap file is inspected (no searching of NIS
  34  *  databases etc).
  35  *
  36  *  There are assumed to be one or more printer names per record, held
  37  *  as a set of sub-fields separated by vertical bar symbols ('|') in the
  38  *  first field of the record. The field separator is assumed to be a colon
  39  *  ':' and the record separator a newline.
  40  *
  41  *  Lines ending with a backspace '\' are assumed to flag that the following
  42  *  line is a continuation line so that a set of lines can be read as one
  43  *  printcap entry.
  44  *
  45  *  A line stating with a hash '#' is assumed to be a comment and is ignored
  46  *  Comments are discarded before the record is strung together from the
  47  *  set of continuation lines.
  48  *
  49  *  Opening a pipe for "lpc status" and reading that would probably
  50  *  be pretty effective. Code to do this already exists in the freely
  51  *  distributable PCNFS server code.
  52  *
  53  *  Modified to call SVID/XPG4 support if printcap name is set to "lpstat"
  54  *  in smb.conf under Solaris.
  55  *
  56  *  Modified to call CUPS support if printcap name is set to "cups"
  57  *  in smb.conf.
  58  *
  59  *  Modified to call iPrint support if printcap name is set to "iprint"
  60  *  in smb.conf.
  61  */
  62
  63 #include "includes.h"
  64
  65
  66 typedef struct pcap_cache {
  67         char *name;
  68         char *comment;
  69         struct pcap_cache *next;
  70 } pcap_cache_t;
  71
  72 static pcap_cache_t *pcap_cache = NULL;
  73
  74 bool pcap_cache_add(const char *name, const char *comment)
  75 {
  76         pcap_cache_t *p;
  77
  78         if (name == NULL || ((p = SMB_MALLOC_P(pcap_cache_t)) == NULL))
  79                 return False;
  80
  81         p->name = SMB_STRDUP(name);
  82         p->comment = (comment && *comment) ? SMB_STRDUP(comment) : NULL;
  83
  84         p->next = pcap_cache;
  85         pcap_cache = p;
  86
  87         return True;
  88 }
  89
  90 static void pcap_cache_destroy(pcap_cache_t *cache)
  91 {
  92         pcap_cache_t *p, *next;
  93
  94         for (p = cache; p != NULL; p = next) {
  95                 next = p->next;
  96
  97                 SAFE_FREE(p->name);
  98                 SAFE_FREE(p->comment);
  99                 SAFE_FREE(p);
 100         }
 101 }
 102
 103 bool pcap_cache_loaded(void)
 104 {
 105         return (pcap_cache != NULL);
 106 }
 107
 108 void pcap_cache_reload(void)
 109 {
 110         const char *pcap_name = lp_printcapname();
 111         bool pcap_reloaded = False;
 112         pcap_cache_t *tmp_cache = NULL;
 113         XFILE *pcap_file;
 114         char *pcap_line;
 115
 116         DEBUG(3, ("reloading printcap cache\n"));
 117
 118         /* only go looking if no printcap name supplied */
 119         if (pcap_name == NULL || *pcap_name == 0) {
 120                 DEBUG(0, ("No printcap file name configured!\n"));
 121                 return;
 122         }
 123
 124         tmp_cache = pcap_cache;
 125         pcap_cache = NULL;
 126
 127 #ifdef HAVE_CUPS
 128         if (strequal(pcap_name, "cups")) {
 129                 pcap_reloaded = cups_cache_reload();
 130                 goto done;
 131         }
 132 #endif
 133
 134 #ifdef HAVE_IPRINT
 135         if (strequal(pcap_name, "iprint")) {
 136                 pcap_reloaded = iprint_cache_reload();
 137                 goto done;
 138         }
 139 #endif
 140
 141 #if defined(SYSV) || defined(HPUX)
 142         if (strequal(pcap_name, "lpstat")) {
 143                 pcap_reloaded = sysv_cache_reload();
 144                 goto done;
 145         }
 146 #endif
 147
 148 #ifdef AIX
 149         if (strstr_m(pcap_name, "/qconfig") != NULL) {
 150                 pcap_reloaded = aix_cache_reload();
 151                 goto done;
 152         }
 153 #endif
 154
 155         /* handle standard printcap - moved from pcap_printer_fn() */
 156
 157         if ((pcap_file = x_fopen(pcap_name, O_RDONLY, 0)) == NULL) {
 158                 DEBUG(0, ("Unable to open printcap file %s for read!\n", pcap_name));
 159                 goto done;
 160         }
 161
 162         for (; (pcap_line = fgets_slash(NULL, 1024, pcap_file)) != NULL; safe_free(pcap_line)) {
 163                 char name[MAXPRINTERLEN+1];
 164                 char comment[62];
 165                 char *p, *q;
 166
 167                 if (*pcap_line == '#' || *pcap_line == 0)
 168                         continue;
 169
 170                 /* now we have a real printer line - cut at the first : */
 171                 if ((p = strchr_m(pcap_line, ':')) != NULL)
 172                         *p = 0;
 173
 174                 /*
 175                  * now find the most likely printer name and comment
 176                  * this is pure guesswork, but it's better than nothing
 177                  */
 178                 for (*name = *comment = 0, p = pcap_line; p != NULL; p = q) {
 179                         bool has_punctuation;
 180
 181                         if ((q = strchr_m(p, '|')) != NULL)
 182                                 *q++ = 0;
 183
 184                         has_punctuation = (strchr_m(p, ' ') ||
 185                                            strchr_m(p, '\t') ||
 186                                            strchr_m(p, '(') ||
 187                                            strchr_m(p, ')'));
 188
 189                         if (strlen(p) > strlen(comment) && has_punctuation) {
 190                                 strlcpy(comment, p, sizeof(comment));
 191                                 continue;
 192                         }
 193
 194                         if (strlen(p) <= MAXPRINTERLEN &&
 195                             strlen(p) > strlen(name) && !has_punctuation) {
 196                                 if (!*comment) {
 197                                         strlcpy(comment, name, sizeof(comment));
 198                                 }
 199                                 strlcpy(name, p, sizeof(name));
 200                                 continue;
 201                         }
 202
 203                         if (!strchr_m(comment, ' ') &&
 204                             strlen(p) > strlen(comment)) {
 205                                 strlcpy(comment, p, sizeof(comment));
 206                                 continue;
 207                         }
 208                 }
 209
 210                 comment[60] = 0;
 211                 name[MAXPRINTERLEN] = 0;
 212
 213                 if (*name && !pcap_cache_add(name, comment)) {
 214                         x_fclose(pcap_file);
 215                         goto done;
 216                 }
 217         }
 218
 219         x_fclose(pcap_file);
 220         pcap_reloaded = True;
 221
 222 done:
 223         DEBUG(3, ("reload status: %s\n", (pcap_reloaded) ? "ok" : "error"));
 224
 225         if (pcap_reloaded)
 226                 pcap_cache_destroy(tmp_cache);
 227         else {
 228                 pcap_cache_destroy(pcap_cache);
 229                 pcap_cache = tmp_cache;
 230         }
 231
 232         return;
 233 }
 234
 235
 236 bool pcap_printername_ok(const char *printername)
 237 {
 238         pcap_cache_t *p;
 239
 240         for (p = pcap_cache; p != NULL; p = p->next)
 241                 if (strequal(p->name, printername))
 242                         return True;
 243
 244         return False;
 245 }
 246
 247 /***************************************************************************
 248 run a function on each printer name in the printcap file. The function is
 249 passed the primary name and the comment (if possible). Note the fn() takes
 250 strings in DOS codepage. This means the xxx_printer_fn() calls must be fixed
 251 to return DOS codepage. FIXME !! JRA.
 252
 253 XXX: I'm not sure if this comment still applies.. Anyone?  -Rob
 254 ***************************************************************************/
 255 void pcap_printer_fn(void (*fn)(char *, char *))
 256 {
 257         pcap_cache_t *p;
 258
 259         for (p = pcap_cache; p != NULL; p = p->next)
 260                 fn(p->name, p->comment);
 261
 262         return;
 263 }