source3/printing/nt_printing.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell              1992-2000,
   5  *  Copyright (C) Jean François Micouleau      1998-2000.
   6  *  Copyright (C) Gerald Carter                     2002.
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  */
  22
  23 #include "includes.h"
  24
  25 extern DOM_SID global_sid_World;
  26
  27 static TDB_CONTEXT *tdb_forms; /* used for forms files */
  28 static TDB_CONTEXT *tdb_drivers; /* used for driver files */
  29 static TDB_CONTEXT *tdb_printers; /* used for printers files */
  30
  31 #define FORMS_PREFIX "FORMS/"
  32 #define DRIVERS_PREFIX "DRIVERS/"
  33 #define DRIVER_INIT_PREFIX "DRIVER_INIT/"
  34 #define PRINTERS_PREFIX "PRINTERS/"
  35 #define SECDESC_PREFIX "SECDESC/"
  36 #define GLOBAL_C_SETPRINTER "GLOBALS/c_setprinter"
  37
  38 #define NTDRIVERS_DATABASE_VERSION_1 1
  39 #define NTDRIVERS_DATABASE_VERSION_2 2
  40 #define NTDRIVERS_DATABASE_VERSION_3 3 /* little endian version of v2 */
  41
  42 #define NTDRIVERS_DATABASE_VERSION NTDRIVERS_DATABASE_VERSION_3
  43
  44 /* Map generic permissions to printer object specific permissions */
  45
  46 GENERIC_MAPPING printer_generic_mapping = {
  47         PRINTER_READ,
  48         PRINTER_WRITE,
  49         PRINTER_EXECUTE,
  50         PRINTER_ALL_ACCESS
  51 };
  52
  53 STANDARD_MAPPING printer_std_mapping = {
  54         PRINTER_READ,
  55         PRINTER_WRITE,
  56         PRINTER_EXECUTE,
  57         PRINTER_ALL_ACCESS
  58 };
  59
  60 /* Map generic permissions to print server object specific permissions */
  61
  62 GENERIC_MAPPING printserver_generic_mapping = {
  63         SERVER_READ,
  64         SERVER_WRITE,
  65         SERVER_EXECUTE,
  66         SERVER_ALL_ACCESS
  67 };
  68
  69 STANDARD_MAPPING printserver_std_mapping = {
  70         SERVER_READ,
  71         SERVER_WRITE,
  72         SERVER_EXECUTE,
  73         SERVER_ALL_ACCESS
  74 };
  75
  76 /* We need one default form to support our default printer. Msoft adds the
  77 forms it wants and in the ORDER it wants them (note: DEVMODE papersize is an
  78 array index). Letter is always first, so (for the current code) additions
  79 always put things in the correct order. */
  80 static nt_forms_struct default_forms[] = {
  81         {"Letter",0x1,0x34b5c,0x44368,0x0,0x0,0x34b5c,0x44368},
  82         {"Letter Small",0x1,0x34b5c,0x44368,0x0,0x0,0x34b5c,0x44368},
  83         {"Tabloid",0x1,0x44368,0x696b8,0x0,0x0,0x44368,0x696b8},
  84         {"Ledger",0x1,0x696b8,0x44368,0x0,0x0,0x696b8,0x44368},
  85         {"Legal",0x1,0x34b5c,0x56d10,0x0,0x0,0x34b5c,0x56d10},
  86         {"Statement",0x1,0x221b4,0x34b5c,0x0,0x0,0x221b4,0x34b5c},
  87         {"Executive",0x1,0x2cf56,0x411cc,0x0,0x0,0x2cf56,0x411cc},
  88         {"A3",0x1,0x48828,0x668a0,0x0,0x0,0x48828,0x668a0},
  89         {"A4",0x1,0x33450,0x48828,0x0,0x0,0x33450,0x48828},
  90         {"A4 Small",0x1,0x33450,0x48828,0x0,0x0,0x33450,0x48828},
  91         {"A5",0x1,0x24220,0x33450,0x0,0x0,0x24220,0x33450},
  92         {"B4 (JIS)",0x1,0x3ebe8,0x58de0,0x0,0x0,0x3ebe8,0x58de0},
  93         {"B5 (JIS)",0x1,0x2c6f0,0x3ebe8,0x0,0x0,0x2c6f0,0x3ebe8},
  94         {"Folio",0x1,0x34b5c,0x509d8,0x0,0x0,0x34b5c,0x509d8},
  95         {"Quarto",0x1,0x347d8,0x43238,0x0,0x0,0x347d8,0x43238},
  96         {"10x14",0x1,0x3e030,0x56d10,0x0,0x0,0x3e030,0x56d10},
  97         {"11x17",0x1,0x44368,0x696b8,0x0,0x0,0x44368,0x696b8},
  98         {"Note",0x1,0x34b5c,0x44368,0x0,0x0,0x34b5c,0x44368},
  99         {"Envelope #9",0x1,0x18079,0x37091,0x0,0x0,0x18079,0x37091},
 100         {"Envelope #10",0x1,0x19947,0x3ae94,0x0,0x0,0x19947,0x3ae94},
 101         {"Envelope #11",0x1,0x1be7c,0x40565,0x0,0x0,0x1be7c,0x40565},
 102         {"Envelope #12",0x1,0x1d74a,0x44368,0x0,0x0,0x1d74a,0x44368},
 103         {"Envelope #14",0x1,0x1f018,0x47504,0x0,0x0,0x1f018,0x47504},
 104         {"C size sheet",0x1,0x696b8,0x886d0,0x0,0x0,0x696b8,0x886d0},
 105         {"D size sheet",0x1,0x886d0,0xd2d70,0x0,0x0,0x886d0,0xd2d70},
 106         {"E size sheet",0x1,0xd2d70,0x110da0,0x0,0x0,0xd2d70,0x110da0},
 107         {"Envelope DL",0x1,0x1adb0,0x35b60,0x0,0x0,0x1adb0,0x35b60},
 108         {"Envelope C5",0x1,0x278d0,0x37e88,0x0,0x0,0x278d0,0x37e88},
 109         {"Envelope C3",0x1,0x4f1a0,0x6fd10,0x0,0x0,0x4f1a0,0x6fd10},
 110         {"Envelope C4",0x1,0x37e88,0x4f1a0,0x0,0x0,0x37e88,0x4f1a0},
 111         {"Envelope C6",0x1,0x1bd50,0x278d0,0x0,0x0,0x1bd50,0x278d0},
 112         {"Envelope C65",0x1,0x1bd50,0x37e88,0x0,0x0,0x1bd50,0x37e88},
 113         {"Envelope B4",0x1,0x3d090,0x562e8,0x0,0x0,0x3d090,0x562e8},
 114         {"Envelope B5",0x1,0x2af80,0x3d090,0x0,0x0,0x2af80,0x3d090},
 115         {"Envelope B6",0x1,0x2af80,0x1e848,0x0,0x0,0x2af80,0x1e848},
 116         {"Envelope",0x1,0x1adb0,0x38270,0x0,0x0,0x1adb0,0x38270},
 117         {"Envelope Monarch",0x1,0x18079,0x2e824,0x0,0x0,0x18079,0x2e824},
 118         {"6 3/4 Envelope",0x1,0x167ab,0x284ec,0x0,0x0,0x167ab,0x284ec},
 119         {"US Std Fanfold",0x1,0x5c3e1,0x44368,0x0,0x0,0x5c3e1,0x44368},
 120         {"German Std Fanfold",0x1,0x34b5c,0x4a6a0,0x0,0x0,0x34b5c,0x4a6a0},
 121         {"German Legal Fanfold",0x1,0x34b5c,0x509d8,0x0,0x0,0x34b5c,0x509d8},
 122         {"B4 (ISO)",0x1,0x3d090,0x562e8,0x0,0x0,0x3d090,0x562e8},
 123         {"Japanese Postcard",0x1,0x186a0,0x24220,0x0,0x0,0x186a0,0x24220},
 124         {"9x11",0x1,0x37cf8,0x44368,0x0,0x0,0x37cf8,0x44368},
 125         {"10x11",0x1,0x3e030,0x44368,0x0,0x0,0x3e030,0x44368},
 126         {"15x11",0x1,0x5d048,0x44368,0x0,0x0,0x5d048,0x44368},
 127         {"Envelope Invite",0x1,0x35b60,0x35b60,0x0,0x0,0x35b60,0x35b60},
 128         {"Reserved48",0x1,0x1,0x1,0x0,0x0,0x1,0x1},
 129         {"Reserved49",0x1,0x1,0x1,0x0,0x0,0x1,0x1},
 130         {"Letter Extra",0x1,0x3ae94,0x4a6a0,0x0,0x0,0x3ae94,0x4a6a0},
 131         {"Legal Extra",0x1,0x3ae94,0x5d048,0x0,0x0,0x3ae94,0x5d048},
 132         {"Tabloid Extra",0x1,0x4a6a0,0x6f9f0,0x0,0x0,0x4a6a0,0x6f9f0},
 133         {"A4 Extra",0x1,0x397c2,0x4eb16,0x0,0x0,0x397c2,0x4eb16},
 134         {"Letter Transverse",0x1,0x34b5c,0x44368,0x0,0x0,0x34b5c,0x44368},
 135         {"A4 Transverse",0x1,0x33450,0x48828,0x0,0x0,0x33450,0x48828},
 136         {"Letter Extra Transverse",0x1,0x3ae94,0x4a6a0,0x0,0x0,0x3ae94,0x4a6a0},
 137         {"Super A",0x1,0x376b8,0x56ea0,0x0,0x0,0x376b8,0x56ea0},
 138         {"Super B",0x1,0x4a768,0x76e58,0x0,0x0,0x4a768,0x76e58},
 139         {"Letter Plus",0x1,0x34b5c,0x4eb16,0x0,0x0,0x34b5c,0x4eb16},
 140         {"A4 Plus",0x1,0x33450,0x50910,0x0,0x0,0x33450,0x50910},
 141         {"A5 Transverse",0x1,0x24220,0x33450,0x0,0x0,0x24220,0x33450},
 142         {"B5 (JIS) Transverse",0x1,0x2c6f0,0x3ebe8,0x0,0x0,0x2c6f0,0x3ebe8},
 143         {"A3 Extra",0x1,0x4e9d0,0x6ca48,0x0,0x0,0x4e9d0,0x6ca48},
 144         {"A5 Extra",0x1,0x2a7b0,0x395f8,0x0,0x0,0x2a7b0,0x395f8},
 145         {"B5 (ISO) Extra",0x1,0x31128,0x43620,0x0,0x0,0x31128,0x43620},
 146         {"A2",0x1,0x668a0,0x91050,0x0,0x0,0x668a0,0x91050},
 147         {"A3 Transverse",0x1,0x48828,0x668a0,0x0,0x0,0x48828,0x668a0},
 148         {"A3 Extra Transverse",0x1,0x4e9d0,0x6ca48,0x0,0x0,0x4e9d0,0x6ca48},
 149         {"Japanese Double Postcard",0x1,0x30d40,0x24220,0x0,0x0,0x30d40,0x24220},
 150         {"A6",0x1,0x19a28,0x24220,0x0,0x0,0x19a28,0x24220},
 151         {"Japanese Envelope Kaku #2",0x1,0x3a980,0x510e0,0x0,0x0,0x3a980,0x510e0},
 152         {"Japanese Envelope Kaku #3",0x1,0x34bc0,0x43a08,0x0,0x0,0x34bc0,0x43a08},
 153         {"Japanese Envelope Chou #3",0x1,0x1d4c0,0x395f8,0x0,0x0,0x1d4c0,0x395f8},
 154         {"Japanese Envelope Chou #4",0x1,0x15f90,0x320c8,0x0,0x0,0x15f90,0x320c8},
 155         {"Letter Rotated",0x1,0x44368,0x34b5c,0x0,0x0,0x44368,0x34b5c},
 156         {"A3 Rotated",0x1,0x668a0,0x48828,0x0,0x0,0x668a0,0x48828},
 157         {"A4 Rotated",0x1,0x48828,0x33450,0x0,0x0,0x48828,0x33450},
 158         {"A5 Rotated",0x1,0x33450,0x24220,0x0,0x0,0x33450,0x24220},
 159         {"B4 (JIS) Rotated",0x1,0x58de0,0x3ebe8,0x0,0x0,0x58de0,0x3ebe8},
 160         {"B5 (JIS) Rotated",0x1,0x3ebe8,0x2c6f0,0x0,0x0,0x3ebe8,0x2c6f0},
 161         {"Japanese Postcard Rotated",0x1,0x24220,0x186a0,0x0,0x0,0x24220,0x186a0},
 162         {"Double Japan Postcard Rotated",0x1,0x24220,0x30d40,0x0,0x0,0x24220,0x30d40},
 163         {"A6 Rotated",0x1,0x24220,0x19a28,0x0,0x0,0x24220,0x19a28},
 164         {"Japan Envelope Kaku #2 Rotated",0x1,0x510e0,0x3a980,0x0,0x0,0x510e0,0x3a980},
 165         {"Japan Envelope Kaku #3 Rotated",0x1,0x43a08,0x34bc0,0x0,0x0,0x43a08, 0x34bc0},
 166         {"Japan Envelope Chou #3 Rotated",0x1,0x395f8,0x1d4c0,0x0,0x0,0x395f8,0x1d4c0},
 167         {"Japan Envelope Chou #4 Rotated",0x1,0x320c8,0x15f90,0x0,0x0,0x320c8,0x15f90},
 168         {"B6 (JIS)",0x1,0x1f400,0x2c6f0,0x0,0x0,0x1f400,0x2c6f0},
 169         {"B6 (JIS) Rotated",0x1,0x2c6f0,0x1f400,0x0,0x0,0x2c6f0,0x1f400},
 170         {"12x11",0x1,0x4a724,0x443e1,0x0,0x0,0x4a724,0x443e1},
 171         {"Japan Envelope You #4",0x1,0x19a28,0x395f8,0x0,0x0,0x19a28,0x395f8},
 172         {"Japan Envelope You #4 Rotated",0x1,0x395f8,0x19a28,0x0,0x0,0x395f8,0x19a28},
 173         {"PRC 16K",0x1,0x2de60,0x3f7a0,0x0,0x0,0x2de60,0x3f7a0},
 174         {"PRC 32K",0x1,0x1fbd0,0x2cec0,0x0,0x0,0x1fbd0,0x2cec0},
 175         {"PRC 32K(Big)",0x1,0x222e0,0x318f8,0x0,0x0,0x222e0,0x318f8},
 176         {"PRC Envelope #1",0x1,0x18e70,0x28488,0x0,0x0,0x18e70,0x28488},
 177         {"PRC Envelope #2",0x1,0x18e70,0x2af80,0x0,0x0,0x18e70,0x2af80},
 178         {"PRC Envelope #3",0x1,0x1e848,0x2af80,0x0,0x0,0x1e848,0x2af80},
 179         {"PRC Envelope #4",0x1,0x1adb0,0x32c80,0x0,0x0,0x1adb0,0x32c80},
 180         {"PRC Envelope #5",0x1,0x1adb0,0x35b60,0x0,0x0,0x1adb0,0x35b60},
 181         {"PRC Envelope #6",0x1,0x1d4c0,0x38270,0x0,0x0,0x1d4c0,0x38270},
 182         {"PRC Envelope #7",0x1,0x27100,0x38270,0x0,0x0,0x27100,0x38270},
 183         {"PRC Envelope #8",0x1,0x1d4c0,0x4b708,0x0,0x0,0x1d4c0,0x4b708},
 184         {"PRC Envelope #9",0x1,0x37e88,0x4f1a0,0x0,0x0,0x37e88,0x4f1a0},
 185         {"PRC Envelope #10",0x1,0x4f1a0,0x6fd10,0x0,0x0,0x4f1a0,0x6fd10},
 186         {"PRC 16K Rotated",0x1,0x3f7a0,0x2de60,0x0,0x0,0x3f7a0,0x2de60},
 187         {"PRC 32K Rotated",0x1,0x2cec0,0x1fbd0,0x0,0x0,0x2cec0,0x1fbd0},
 188         {"PRC 32K(Big) Rotated",0x1,0x318f8,0x222e0,0x0,0x0,0x318f8,0x222e0},
 189         {"PRC Envelope #1 Rotated",0x1,0x28488,0x18e70,0x0,0x0,0x28488,0x18e70},
 190         {"PRC Envelope #2 Rotated",0x1,0x2af80,0x18e70,0x0,0x0,0x2af80,0x18e70},
 191         {"PRC Envelope #3 Rotated",0x1,0x2af80,0x1e848,0x0,0x0,0x2af80,0x1e848},
 192         {"PRC Envelope #4 Rotated",0x1,0x32c80,0x1adb0,0x0,0x0,0x32c80,0x1adb0},
 193         {"PRC Envelope #5 Rotated",0x1,0x35b60,0x1adb0,0x0,0x0,0x35b60,0x1adb0},
 194         {"PRC Envelope #6 Rotated",0x1,0x38270,0x1d4c0,0x0,0x0,0x38270,0x1d4c0},
 195         {"PRC Envelope #7 Rotated",0x1,0x38270,0x27100,0x0,0x0,0x38270,0x27100},
 196         {"PRC Envelope #8 Rotated",0x1,0x4b708,0x1d4c0,0x0,0x0,0x4b708,0x1d4c0},
 197         {"PRC Envelope #9 Rotated",0x1,0x4f1a0,0x37e88,0x0,0x0,0x4f1a0,0x37e88},
 198         {"PRC Envelope #10 Rotated",0x1,0x6fd10,0x4f1a0,0x0,0x0,0x6fd10,0x4f1a0}
 199 };
 200
 201 static BOOL upgrade_to_version_3(void)
 202 {
 203         TDB_DATA kbuf, newkey, dbuf;
 204
 205         DEBUG(0,("upgrade_to_version_3: upgrading print tdb's to version 3\n"));
 206
 207         for (kbuf = tdb_firstkey(tdb_drivers); kbuf.dptr;
 208                         newkey = tdb_nextkey(tdb_drivers, kbuf), safe_free(kbuf.dptr), kbuf=newkey) {
 209
 210                 dbuf = tdb_fetch(tdb_drivers, kbuf);
 211
 212                 if (strncmp(kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) == 0) {
 213                         DEBUG(0,("upgrade_to_version_3:moving form\n"));
 214                         if (tdb_store(tdb_forms, kbuf, dbuf, TDB_REPLACE) != 0) {
 215                                 SAFE_FREE(dbuf.dptr);
 216                                 DEBUG(0,("upgrade_to_version_3: failed to move form. Error (%s).\n", tdb_errorstr(tdb_forms)));
 217                                 return False;
 218                         }
 219                         if (tdb_delete(tdb_drivers, kbuf) != 0) {
 220                                 SAFE_FREE(dbuf.dptr);
 221                                 DEBUG(0,("upgrade_to_version_3: failed to delete form. Error (%s)\n", tdb_errorstr(tdb_drivers)));
 222                                 return False;
 223                         }
 224                 }
 225
 226                 if (strncmp(kbuf.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX)) == 0) {
 227                         DEBUG(0,("upgrade_to_version_3:moving printer\n"));
 228                         if (tdb_store(tdb_printers, kbuf, dbuf, TDB_REPLACE) != 0) {
 229                                 SAFE_FREE(dbuf.dptr);
 230                                 DEBUG(0,("upgrade_to_version_3: failed to move printer. Error (%s)\n", tdb_errorstr(tdb_printers)));
 231                                 return False;
 232                         }
 233                         if (tdb_delete(tdb_drivers, kbuf) != 0) {
 234                                 SAFE_FREE(dbuf.dptr);
 235                                 DEBUG(0,("upgrade_to_version_3: failed to delete printer. Error (%s)\n", tdb_errorstr(tdb_drivers)));
 236                                 return False;
 237                         }
 238                 }
 239
 240                 if (strncmp(kbuf.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX)) == 0) {
 241                         DEBUG(0,("upgrade_to_version_3:moving secdesc\n"));
 242                         if (tdb_store(tdb_printers, kbuf, dbuf, TDB_REPLACE) != 0) {
 243                                 SAFE_FREE(dbuf.dptr);
 244                                 DEBUG(0,("upgrade_to_version_3: failed to move secdesc. Error (%s)\n", tdb_errorstr(tdb_printers)));
 245                                 return False;
 246                         }
 247                         if (tdb_delete(tdb_drivers, kbuf) != 0) {
 248                                 SAFE_FREE(dbuf.dptr);
 249                                 DEBUG(0,("upgrade_to_version_3: failed to delete secdesc. Error (%s)\n", tdb_errorstr(tdb_drivers)));
 250                                 return False;
 251                         }
 252                 }
 253
 254                 SAFE_FREE(dbuf.dptr);
 255         }
 256
 257         return True;
 258 }
 259
 260 /****************************************************************************
 261  Open the NT printing tdbs. Done once before fork().
 262 ****************************************************************************/
 263
 264 BOOL nt_printing_init(void)
 265 {
 266         static pid_t local_pid;
 267         char *vstring = "INFO/version";
 268
 269         if (tdb_drivers && tdb_printers && tdb_forms && local_pid == sys_getpid())
 270                 return True;
 271
 272         if (tdb_drivers)
 273                 tdb_close(tdb_drivers);
 274         tdb_drivers = tdb_open_log(lock_path("ntdrivers.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
 275         if (!tdb_drivers) {
 276                 DEBUG(0,("nt_printing_init: Failed to open nt drivers database %s (%s)\n",
 277                         lock_path("ntdrivers.tdb"), strerror(errno) ));
 278                 return False;
 279         }
 280
 281         if (tdb_printers)
 282                 tdb_close(tdb_printers);
 283         tdb_printers = tdb_open_log(lock_path("ntprinters.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
 284         if (!tdb_printers) {
 285                 DEBUG(0,("nt_printing_init: Failed to open nt printers database %s (%s)\n",
 286                         lock_path("ntprinters.tdb"), strerror(errno) ));
 287                 return False;
 288         }
 289
 290         if (tdb_forms)
 291                 tdb_close(tdb_forms);
 292         tdb_forms = tdb_open_log(lock_path("ntforms.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
 293         if (!tdb_forms) {
 294                 DEBUG(0,("nt_printing_init: Failed to open nt forms database %s (%s)\n",
 295                         lock_path("ntforms.tdb"), strerror(errno) ));
 296                 return False;
 297         }
 298
 299         local_pid = sys_getpid();
 300
 301         /* handle a Samba upgrade */
 302         tdb_lock_bystring(tdb_drivers, vstring, 0);
 303         {
 304                 int32 vers_id;
 305
 306                 /* Cope with byte-reversed older versions of the db. */
 307                 vers_id = tdb_fetch_int32(tdb_drivers, vstring);
 308                 if ((vers_id == NTDRIVERS_DATABASE_VERSION_2) || (IREV(vers_id) == NTDRIVERS_DATABASE_VERSION_2)) {
 309                         /* Written on a bigendian machine with old fetch_int code. Save as le. */
 310                         /* The only upgrade between V2 and V3 is to save the version in little-endian. */
 311                         tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION);
 312                         vers_id = NTDRIVERS_DATABASE_VERSION;
 313                 }
 314
 315                 if (vers_id != NTDRIVERS_DATABASE_VERSION) {
 316
 317                         if ((vers_id == NTDRIVERS_DATABASE_VERSION_1) || (IREV(vers_id) == NTDRIVERS_DATABASE_VERSION_1)) {
 318                                 if (!upgrade_to_version_3())
 319                                         return False;
 320                         } else
 321                                 tdb_traverse(tdb_drivers, tdb_traverse_delete_fn, NULL);
 322
 323                         tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION);
 324                 }
 325         }
 326         tdb_unlock_bystring(tdb_drivers, vstring);
 327
 328         update_c_setprinter(True);
 329
 330         /*
 331          * register callback to handle updating printers as new
 332          * drivers are installed
 333          */
 334
 335         message_register( MSG_PRINTER_DRVUPGRADE, do_drv_upgrade_printer );
 336
 337         /*
 338          * register callback to handle updating printer data
 339          * when a driver is initialized
 340          */
 341
 342         message_register( MSG_PRINTERDATA_INIT_RESET, reset_all_printerdata );
 343
 344
 345         return True;
 346 }
 347
 348 /*******************************************************************
 349  tdb traversal function for counting printers.
 350 ********************************************************************/
 351
 352 static int traverse_counting_printers(TDB_CONTEXT *t, TDB_DATA key,
 353                                       TDB_DATA data, void *context)
 354 {
 355         int *printer_count = (int*)context;
 356
 357         if (memcmp(PRINTERS_PREFIX, key.dptr, sizeof(PRINTERS_PREFIX)-1) == 0) {
 358                 (*printer_count)++;
 359                 DEBUG(10,("traverse_counting_printers: printer = [%s]  printer_count = %d\n", key.dptr, *printer_count));
 360         }
 361
 362         return 0;
 363 }
 364
 365 /*******************************************************************
 366  Update the spooler global c_setprinter. This variable is initialized
 367  when the parent smbd starts with the number of existing printers. It
 368  is monotonically increased by the current number of printers *after*
 369  each add or delete printer RPC. Only Microsoft knows why... JRR020119
 370 ********************************************************************/
 371
 372 uint32 update_c_setprinter(BOOL initialize)
 373 {
 374         int32 c_setprinter;
 375         int32 printer_count = 0;
 376
 377         tdb_lock_bystring(tdb_printers, GLOBAL_C_SETPRINTER, 0);
 378
 379         /* Traverse the tdb, counting the printers */
 380         tdb_traverse(tdb_printers, traverse_counting_printers, (void *)&printer_count);
 381
 382         /* If initializing, set c_setprinter to current printers count
 383          * otherwise, bump it by the current printer count
 384          */
 385         if (!initialize)
 386                 c_setprinter = tdb_fetch_int32(tdb_printers, GLOBAL_C_SETPRINTER) + printer_count;
 387         else
 388                 c_setprinter = printer_count;
 389
 390         DEBUG(10,("update_c_setprinter: c_setprinter = %u\n", (unsigned int)c_setprinter));
 391         tdb_store_int32(tdb_printers, GLOBAL_C_SETPRINTER, c_setprinter);
 392
 393         tdb_unlock_bystring(tdb_printers, GLOBAL_C_SETPRINTER);
 394
 395         return (uint32)c_setprinter;
 396 }
 397
 398 /*******************************************************************
 399  Get the spooler global c_setprinter, accounting for initialization.
 400 ********************************************************************/
 401
 402 uint32 get_c_setprinter(void)
 403 {
 404         int32 c_setprinter = tdb_fetch_int32(tdb_printers, GLOBAL_C_SETPRINTER);
 405
 406         if (c_setprinter == (int32)-1)
 407                 c_setprinter = update_c_setprinter(True);
 408
 409         DEBUG(10,("get_c_setprinter: c_setprinter = %d\n", c_setprinter));
 410
 411         return (uint32)c_setprinter;
 412 }
 413
 414 /****************************************************************************
 415  Get builtin form struct list.
 416 ****************************************************************************/
 417
 418 int get_builtin_ntforms(nt_forms_struct **list)
 419 {
 420         *list = (nt_forms_struct *)memdup(&default_forms[0], sizeof(default_forms));
 421         return sizeof(default_forms) / sizeof(default_forms[0]);
 422 }
 423
 424 /****************************************************************************
 425  get a builtin form struct
 426 ****************************************************************************/
 427
 428 BOOL get_a_builtin_ntform(UNISTR2 *uni_formname,nt_forms_struct *form)
 429 {
 430         int i,count;
 431         fstring form_name;
 432         unistr2_to_ascii(form_name, uni_formname, sizeof(form_name)-1);
 433         DEBUGADD(6,("Looking for builtin form %s \n", form_name));
 434         count = sizeof(default_forms) / sizeof(default_forms[0]);
 435         for (i=0;i<count;i++) {
 436                 if (strequal(form_name,default_forms[i].name)) {
 437                         DEBUGADD(6,("Found builtin form %s \n", form_name));
 438                         memcpy(form,&default_forms[i],sizeof(*form));
 439                         break;
 440                 }
 441         }
 442
 443         return (i !=count);
 444 }
 445
 446 /****************************************************************************
 447 get a form struct list
 448 ****************************************************************************/
 449 int get_ntforms(nt_forms_struct **list)
 450 {
 451         TDB_DATA kbuf, newkey, dbuf;
 452         nt_forms_struct *tl;
 453         nt_forms_struct form;
 454         int ret;
 455         int i;
 456         int n = 0;
 457
 458         for (kbuf = tdb_firstkey(tdb_forms);
 459              kbuf.dptr;
 460              newkey = tdb_nextkey(tdb_forms, kbuf), safe_free(kbuf.dptr), kbuf=newkey)
 461         {
 462                 if (strncmp(kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) != 0)
 463                         continue;
 464
 465                 dbuf = tdb_fetch(tdb_forms, kbuf);
 466                 if (!dbuf.dptr)
 467                         continue;
 468
 469                 fstrcpy(form.name, kbuf.dptr+strlen(FORMS_PREFIX));
 470                 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "dddddddd",
 471                                  &i, &form.flag, &form.width, &form.length, &form.left,
 472                                  &form.top, &form.right, &form.bottom);
 473                 SAFE_FREE(dbuf.dptr);
 474                 if (ret != dbuf.dsize)
 475                         continue;
 476
 477                 tl = Realloc(*list, sizeof(nt_forms_struct)*(n+1));
 478                 if (!tl) {
 479                         DEBUG(0,("get_ntforms: Realloc fail.\n"));
 480                         return 0;
 481                 }
 482                 *list = tl;
 483                 (*list)[n] = form;
 484                 n++;
 485         }
 486
 487
 488         return n;
 489 }
 490
 491 /****************************************************************************
 492 write a form struct list
 493 ****************************************************************************/
 494 int write_ntforms(nt_forms_struct **list, int number)
 495 {
 496         pstring buf, key;
 497         int len;
 498         TDB_DATA kbuf,dbuf;
 499         int i;
 500
 501         for (i=0;i<number;i++) {
 502                 /* save index, so list is rebuilt in correct order */
 503                 len = tdb_pack(buf, sizeof(buf), "dddddddd",
 504                                i, (*list)[i].flag, (*list)[i].width, (*list)[i].length,
 505                                (*list)[i].left, (*list)[i].top, (*list)[i].right,
 506                                (*list)[i].bottom);
 507                 if (len > sizeof(buf)) break;
 508                 slprintf(key, sizeof(key)-1, "%s%s", FORMS_PREFIX, (*list)[i].name);
 509                 kbuf.dsize = strlen(key)+1;
 510                 kbuf.dptr = key;
 511                 dbuf.dsize = len;
 512                 dbuf.dptr = buf;
 513                 if (tdb_store(tdb_forms, kbuf, dbuf, TDB_REPLACE) != 0) break;
 514        }
 515
 516        return i;
 517 }
 518
 519 /****************************************************************************
 520 add a form struct at the end of the list
 521 ****************************************************************************/
 522 BOOL add_a_form(nt_forms_struct **list, const FORM *form, int *count)
 523 {
 524         int n=0;
 525         BOOL update;
 526         fstring form_name;
 527         nt_forms_struct *tl;
 528
 529         /*
 530          * NT tries to add forms even when
 531          * they are already in the base
 532          * only update the values if already present
 533          */
 534
 535         update=False;
 536
 537         unistr2_to_ascii(form_name, &form->name, sizeof(form_name)-1);
 538         for (n=0; n<*count; n++) {
 539                 if (!strncmp((*list)[n].name, form_name, strlen(form_name))) {
 540                         DEBUG(103, ("NT workaround, [%s] already exists\n", form_name));
 541                         update=True;
 542                         break;
 543                 }
 544         }
 545
 546         if (update==False) {
 547                 if((tl=Realloc(*list, (n+1)*sizeof(nt_forms_struct))) == NULL) {
 548                         DEBUG(0,("add_a_form: failed to enlarge forms list!\n"));
 549                         return False;
 550                 }
 551                 *list = tl;
 552                 unistr2_to_ascii((*list)[n].name, &form->name, sizeof((*list)[n].name)-1);
 553                 (*count)++;
 554         }
 555
 556         (*list)[n].flag=form->flags;
 557         (*list)[n].width=form->size_x;
 558         (*list)[n].length=form->size_y;
 559         (*list)[n].left=form->left;
 560         (*list)[n].top=form->top;
 561         (*list)[n].right=form->right;
 562         (*list)[n].bottom=form->bottom;
 563
 564         return True;
 565 }
 566
 567 /****************************************************************************
 568  delete a named form struct
 569 ****************************************************************************/
 570 BOOL delete_a_form(nt_forms_struct **list, UNISTR2 *del_name, int *count, WERROR *ret)
 571 {
 572         pstring key;
 573         TDB_DATA kbuf;
 574         int n=0;
 575         fstring form_name;
 576
 577         *ret = WERR_OK;
 578
 579         unistr2_to_ascii(form_name, del_name, sizeof(form_name)-1);
 580
 581         for (n=0; n<*count; n++) {
 582                 if (!strncmp((*list)[n].name, form_name, strlen(form_name))) {
 583                         DEBUG(103, ("delete_a_form, [%s] in list\n", form_name));
 584                         break;
 585                 }
 586         }
 587
 588         if (n == *count) {
 589                 DEBUG(10,("delete_a_form, [%s] not found\n", form_name));
 590                 *ret = WERR_INVALID_PARAM;
 591                 return False;
 592         }
 593
 594         slprintf(key, sizeof(key)-1, "%s%s", FORMS_PREFIX, (*list)[n].name);
 595         kbuf.dsize = strlen(key)+1;
 596         kbuf.dptr = key;
 597         if (tdb_delete(tdb_forms, kbuf) != 0) {
 598                 *ret = WERR_NOMEM;
 599                 return False;
 600         }
 601
 602         return True;
 603 }
 604
 605 /****************************************************************************
 606 update a form struct
 607 ****************************************************************************/
 608 void update_a_form(nt_forms_struct **list, const FORM *form, int count)
 609 {
 610         int n=0;
 611         fstring form_name;
 612         unistr2_to_ascii(form_name, &(form->name), sizeof(form_name)-1);
 613
 614         DEBUG(106, ("[%s]\n", form_name));
 615         for (n=0; n<count; n++)
 616         {
 617                 DEBUGADD(106, ("n [%d]:[%s]\n", n, (*list)[n].name));
 618                 if (!strncmp((*list)[n].name, form_name, strlen(form_name)))
 619                         break;
 620         }
 621
 622         if (n==count) return;
 623
 624         (*list)[n].flag=form->flags;
 625         (*list)[n].width=form->size_x;
 626         (*list)[n].length=form->size_y;
 627         (*list)[n].left=form->left;
 628         (*list)[n].top=form->top;
 629         (*list)[n].right=form->right;
 630         (*list)[n].bottom=form->bottom;
 631 }
 632
 633 /****************************************************************************
 634 get the nt drivers list
 635
 636 traverse the database and look-up the matching names
 637 ****************************************************************************/
 638 int get_ntdrivers(fstring **list, char *architecture, uint32 version)
 639 {
 640         int total=0;
 641         fstring short_archi;
 642         fstring *fl;
 643         pstring key;
 644         TDB_DATA kbuf, newkey;
 645
 646         get_short_archi(short_archi, architecture);
 647         slprintf(key, sizeof(key)-1, "%s%s/%d/", DRIVERS_PREFIX, short_archi, version);
 648
 649         for (kbuf = tdb_firstkey(tdb_drivers);
 650              kbuf.dptr;
 651              newkey = tdb_nextkey(tdb_drivers, kbuf), safe_free(kbuf.dptr), kbuf=newkey) {
 652                 if (strncmp(kbuf.dptr, key, strlen(key)) != 0) continue;
 653
 654                 if((fl = Realloc(*list, sizeof(fstring)*(total+1))) == NULL) {
 655                         DEBUG(0,("get_ntdrivers: failed to enlarge list!\n"));
 656                         return -1;
 657                 }
 658                 else *list = fl;
 659
 660                 fstrcpy((*list)[total], kbuf.dptr+strlen(key));
 661                 total++;
 662         }
 663
 664         return(total);
 665 }
 666
 667 /****************************************************************************
 668 function to do the mapping between the long architecture name and
 669 the short one.
 670 ****************************************************************************/
 671 BOOL get_short_archi(char *short_archi, char *long_archi)
 672 {
 673         struct table {
 674                 char *long_archi;
 675                 char *short_archi;
 676         };
 677
 678         struct table archi_table[]=
 679         {
 680                 {"Windows 4.0",          "WIN40"    },
 681                 {"Windows NT x86",       "W32X86"   },
 682                 {"Windows NT R4000",     "W32MIPS"  },
 683                 {"Windows NT Alpha_AXP", "W32ALPHA" },
 684                 {"Windows NT PowerPC",   "W32PPC"   },
 685                 {NULL,                   ""         }
 686         };
 687
 688         int i=-1;
 689
 690         DEBUG(107,("Getting architecture dependant directory\n"));
 691
 692         if (long_archi == NULL) {
 693                 DEBUGADD(107,("Bad long_archi param.!\n"));
 694                 return False;
 695         }
 696
 697         do {
 698                 i++;
 699         } while ( (archi_table[i].long_archi!=NULL ) &&
 700                   StrCaseCmp(long_archi, archi_table[i].long_archi) );
 701
 702         if (archi_table[i].long_archi==NULL) {
 703                 DEBUGADD(107,("Unknown architecture [%s] !\n", long_archi));
 704                 return False;
 705         }
 706
 707         StrnCpy (short_archi, archi_table[i].short_archi, strlen(archi_table[i].short_archi));
 708
 709         DEBUGADD(108,("index: [%d]\n", i));
 710         DEBUGADD(108,("long architecture: [%s]\n", long_archi));
 711         DEBUGADD(108,("short architecture: [%s]\n", short_archi));
 712
 713         return True;
 714 }
 715
 716 /****************************************************************************
 717  Version information in Microsoft files is held in a VS_VERSION_INFO structure.
 718  There are two case to be covered here: PE (Portable Executable) and NE (New
 719  Executable) files. Both files support the same INFO structure, but PE files
 720  store the signature in unicode, and NE files store it as !unicode.
 721  returns -1 on error, 1 on version info found, and 0 on no version info found.
 722 ****************************************************************************/
 723
 724 static int get_file_version(files_struct *fsp, char *fname,uint32 *major, uint32 *minor)
 725 {
 726         int     i;
 727         char    *buf;
 728         ssize_t byte_count;
 729
 730         if ((buf=malloc(PE_HEADER_SIZE)) == NULL) {
 731                 DEBUG(0,("get_file_version: PE file [%s] PE Header malloc failed bytes = %d\n",
 732                                 fname, PE_HEADER_SIZE));
 733                 goto error_exit;
 734         }
 735
 736         /* Note: DOS_HEADER_SIZE < malloc'ed PE_HEADER_SIZE */
 737         if ((byte_count = vfs_read_data(fsp, buf, DOS_HEADER_SIZE)) < DOS_HEADER_SIZE) {
 738                 DEBUG(3,("get_file_version: File [%s] DOS header too short, bytes read = %d\n",
 739                                 fname, byte_count));
 740                 goto no_version_info;
 741         }
 742
 743         /* Is this really a DOS header? */
 744         if (SVAL(buf,DOS_HEADER_MAGIC_OFFSET) != DOS_HEADER_MAGIC) {
 745                 DEBUG(6,("get_file_version: File [%s] bad DOS magic = 0x%x\n",
 746                                 fname, SVAL(buf,DOS_HEADER_MAGIC_OFFSET)));
 747                 goto no_version_info;
 748         }
 749
 750         /* Skip OEM header (if any) and the DOS stub to start of Windows header */
 751         if (fsp->conn->vfs_ops.lseek(fsp, fsp->fd, SVAL(buf,DOS_HEADER_LFANEW_OFFSET), SEEK_SET) == (SMB_OFF_T)-1) {
 752                 DEBUG(3,("get_file_version: File [%s] too short, errno = %d\n",
 753                                 fname, errno));
 754                 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
 755                 goto no_version_info;
 756         }
 757
 758         if ((byte_count = vfs_read_data(fsp, buf, PE_HEADER_SIZE)) < PE_HEADER_SIZE) {
 759                 DEBUG(3,("get_file_version: File [%s] Windows header too short, bytes read = %d\n",
 760                                 fname, byte_count));
 761                 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
 762                 goto no_version_info;
 763         }
 764
 765         /* The header may be a PE (Portable Executable) or an NE (New Executable) */
 766         if (IVAL(buf,PE_HEADER_SIGNATURE_OFFSET) == PE_HEADER_SIGNATURE) {
 767                 int num_sections;
 768                 int section_table_bytes;
 769
 770                 if (SVAL(buf,PE_HEADER_MACHINE_OFFSET) != PE_HEADER_MACHINE_I386) {
 771                         DEBUG(3,("get_file_version: PE file [%s] wrong machine = 0x%x\n",
 772                                         fname, SVAL(buf,PE_HEADER_MACHINE_OFFSET)));
 773                         /* At this point, we assume the file is in error. It still could be somthing
 774                          * else besides a PE file, but it unlikely at this point.
 775                          */
 776                         goto error_exit;
 777                 }
 778
 779                 /* get the section table */
 780                 num_sections        = SVAL(buf,PE_HEADER_NUMBER_OF_SECTIONS);
 781                 section_table_bytes = num_sections * PE_HEADER_SECT_HEADER_SIZE;
 782                 SAFE_FREE(buf);
 783                 if ((buf=malloc(section_table_bytes)) == NULL) {
 784                         DEBUG(0,("get_file_version: PE file [%s] section table malloc failed bytes = %d\n",
 785                                         fname, section_table_bytes));
 786                         goto error_exit;
 787                 }
 788
 789                 if ((byte_count = vfs_read_data(fsp, buf, section_table_bytes)) < section_table_bytes) {
 790                         DEBUG(3,("get_file_version: PE file [%s] Section header too short, bytes read = %d\n",
 791                                         fname, byte_count));
 792                         goto error_exit;
 793                 }
 794
 795                 /* Iterate the section table looking for the resource section ".rsrc" */
 796                 for (i = 0; i < num_sections; i++) {
 797                         int sec_offset = i * PE_HEADER_SECT_HEADER_SIZE;
 798
 799                         if (strcmp(".rsrc", &buf[sec_offset+PE_HEADER_SECT_NAME_OFFSET]) == 0) {
 800                                 int section_pos   = IVAL(buf,sec_offset+PE_HEADER_SECT_PTR_DATA_OFFSET);
 801                                 int section_bytes = IVAL(buf,sec_offset+PE_HEADER_SECT_SIZE_DATA_OFFSET);
 802
 803                                 SAFE_FREE(buf);
 804                                 if ((buf=malloc(section_bytes)) == NULL) {
 805                                         DEBUG(0,("get_file_version: PE file [%s] version malloc failed bytes = %d\n",
 806                                                         fname, section_bytes));
 807                                         goto error_exit;
 808                                 }
 809
 810                                 /* Seek to the start of the .rsrc section info */
 811                                 if (fsp->conn->vfs_ops.lseek(fsp, fsp->fd, section_pos, SEEK_SET) == (SMB_OFF_T)-1) {
 812                                         DEBUG(3,("get_file_version: PE file [%s] too short for section info, errno = %d\n",
 813                                                         fname, errno));
 814                                         goto error_exit;
 815                                 }
 816
 817                                 if ((byte_count = vfs_read_data(fsp, buf, section_bytes)) < section_bytes) {
 818                                         DEBUG(3,("get_file_version: PE file [%s] .rsrc section too short, bytes read = %d\n",
 819                                                         fname, byte_count));
 820                                         goto error_exit;
 821                                 }
 822
 823                                 for (i=0; i<section_bytes-VS_VERSION_INFO_UNICODE_SIZE; i++) {
 824                                         /* Scan for 1st 3 unicoded bytes followed by word aligned magic value */
 825                                         if (buf[i] == 'V' && buf[i+1] == '\0' && buf[i+2] == 'S') {
 826                                                 /* Align to next long address */
 827                                                 int pos = (i + sizeof(VS_SIGNATURE)*2 + 3) & 0xfffffffc;
 828
 829                                                 if (IVAL(buf,pos) == VS_MAGIC_VALUE) {
 830                                                         *major = IVAL(buf,pos+VS_MAJOR_OFFSET);
 831                                                         *minor = IVAL(buf,pos+VS_MINOR_OFFSET);
 832
 833                                                         DEBUG(6,("get_file_version: PE file [%s] Version = %08x:%08x (%d.%d.%d.%d)\n",
 834                                                                           fname, *major, *minor,
 835                                                                           (*major>>16)&0xffff, *major&0xffff,
 836                                                                           (*minor>>16)&0xffff, *minor&0xffff));
 837                                                         SAFE_FREE(buf);
 838                                                         return 1;
 839                                                 }
 840                                         }
 841                                 }
 842                         }
 843                 }
 844
 845                 /* Version info not found, fall back to origin date/time */
 846                 DEBUG(10,("get_file_version: PE file [%s] has no version info\n", fname));
 847                 SAFE_FREE(buf);
 848                 return 0;
 849
 850         } else if (SVAL(buf,NE_HEADER_SIGNATURE_OFFSET) == NE_HEADER_SIGNATURE) {
 851                 if (CVAL(buf,NE_HEADER_TARGET_OS_OFFSET) != NE_HEADER_TARGOS_WIN ) {
 852                         DEBUG(3,("get_file_version: NE file [%s] wrong target OS = 0x%x\n",
 853                                         fname, CVAL(buf,NE_HEADER_TARGET_OS_OFFSET)));
 854                         /* At this point, we assume the file is in error. It still could be somthing
 855                          * else besides a NE file, but it unlikely at this point. */
 856                         goto error_exit;
 857                 }
 858
 859                 /* Allocate a bit more space to speed up things */
 860                 SAFE_FREE(buf);
 861                 if ((buf=malloc(VS_NE_BUF_SIZE)) == NULL) {
 862                         DEBUG(0,("get_file_version: NE file [%s] malloc failed bytes  = %d\n",
 863                                         fname, PE_HEADER_SIZE));
 864                         goto error_exit;
 865                 }
 866
 867                 /* This is a HACK! I got tired of trying to sort through the messy
 868                  * 'NE' file format. If anyone wants to clean this up please have at
 869                  * it, but this works. 'NE' files will eventually fade away. JRR */
 870                 while((byte_count = vfs_read_data(fsp, buf, VS_NE_BUF_SIZE)) > 0) {
 871                         /* Cover case that should not occur in a well formed 'NE' .dll file */
 872                         if (byte_count-VS_VERSION_INFO_SIZE <= 0) break;
 873
 874                         for(i=0; i<byte_count; i++) {
 875                                 /* Fast skip past data that can't possibly match */
 876                                 if (buf[i] != 'V') continue;
 877
 878                                 /* Potential match data crosses buf boundry, move it to beginning
 879                                  * of buf, and fill the buf with as much as it will hold. */
 880                                 if (i>byte_count-VS_VERSION_INFO_SIZE) {
 881                                         int bc;
 882
 883                                         memcpy(buf, &buf[i], byte_count-i);
 884                                         if ((bc = vfs_read_data(fsp, &buf[byte_count-i], VS_NE_BUF_SIZE-
 885                                                                    (byte_count-i))) < 0) {
 886
 887                                                 DEBUG(0,("get_file_version: NE file [%s] Read error, errno=%d\n",
 888                                                                  fname, errno));
 889                                                 goto error_exit;
 890                                         }
 891
 892                                         byte_count = bc + (byte_count - i);
 893                                         if (byte_count<VS_VERSION_INFO_SIZE) break;
 894
 895                                         i = 0;
 896                                 }
 897
 898                                 /* Check that the full signature string and the magic number that
 899                                  * follows exist (not a perfect solution, but the chances that this
 900                                  * occurs in code is, well, remote. Yes I know I'm comparing the 'V'
 901                                  * twice, as it is simpler to read the code. */
 902                                 if (strcmp(&buf[i], VS_SIGNATURE) == 0) {
 903                                         /* Compute skip alignment to next long address */
 904                                         int skip = -(fsp->conn->vfs_ops.lseek(fsp, fsp->fd, 0, SEEK_CUR) - (byte_count - i) +
 905                                                                  sizeof(VS_SIGNATURE)) & 3;
 906                                         if (IVAL(buf,i+sizeof(VS_SIGNATURE)+skip) != 0xfeef04bd) continue;
 907
 908                                         *major = IVAL(buf,i+sizeof(VS_SIGNATURE)+skip+VS_MAJOR_OFFSET);
 909                                         *minor = IVAL(buf,i+sizeof(VS_SIGNATURE)+skip+VS_MINOR_OFFSET);
 910                                         DEBUG(6,("get_file_version: NE file [%s] Version = %08x:%08x (%d.%d.%d.%d)\n",
 911                                                           fname, *major, *minor,
 912                                                           (*major>>16)&0xffff, *major&0xffff,
 913                                                           (*minor>>16)&0xffff, *minor&0xffff));
 914                                         SAFE_FREE(buf);
 915                                         return 1;
 916                                 }
 917                         }
 918                 }
 919
 920                 /* Version info not found, fall back to origin date/time */
 921                 DEBUG(0,("get_file_version: NE file [%s] Version info not found\n", fname));
 922                 SAFE_FREE(buf);
 923                 return 0;
 924
 925         } else
 926                 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
 927                 DEBUG(3,("get_file_version: File [%s] unknown file format, signature = 0x%x\n",
 928                                 fname, IVAL(buf,PE_HEADER_SIGNATURE_OFFSET)));
 929
 930         no_version_info:
 931                 SAFE_FREE(buf);
 932                 return 0;
 933
 934         error_exit:
 935                 SAFE_FREE(buf);
 936                 return -1;
 937 }
 938
 939 /****************************************************************************
 940 Drivers for Microsoft systems contain multiple files. Often, multiple drivers
 941 share one or more files. During the MS installation process files are checked
 942 to insure that only a newer version of a shared file is installed over an
 943 older version. There are several possibilities for this comparison. If there
 944 is no previous version, the new one is newer (obviously). If either file is
 945 missing the version info structure, compare the creation date (on Unix use
 946 the modification date). Otherwise chose the numerically larger version number.
 947 ****************************************************************************/
 948 static int file_version_is_newer(connection_struct *conn, fstring new_file,
 949                                                                 fstring old_file)
 950 {
 951         BOOL   use_version = True;
 952         pstring filepath;
 953
 954         uint32 new_major;
 955         uint32 new_minor;
 956         time_t new_create_time;
 957
 958         uint32 old_major;
 959         uint32 old_minor;
 960         time_t old_create_time;
 961
 962         int access_mode;
 963         int action;
 964         files_struct    *fsp = NULL;
 965         SMB_STRUCT_STAT st;
 966         SMB_STRUCT_STAT stat_buf;
 967         BOOL bad_path;
 968
 969         ZERO_STRUCT(st);
 970         ZERO_STRUCT(stat_buf);
 971         new_create_time = (time_t)0;
 972         old_create_time = (time_t)0;
 973
 974         /* Get file version info (if available) for previous file (if it exists) */
 975         pstrcpy(filepath, old_file);
 976
 977         unix_convert(filepath,conn,NULL,&bad_path,&stat_buf);
 978
 979         fsp = open_file_shared(conn, filepath, &stat_buf,
 980                                                    SET_OPEN_MODE(DOS_OPEN_RDONLY),
 981                                                    (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),
 982                                                    0, 0, &access_mode, &action);
 983         if (!fsp) {
 984                 /* Old file not found, so by definition new file is in fact newer */
 985                 DEBUG(10,("file_version_is_newer: Can't open old file [%s], errno = %d\n",
 986                                 filepath, errno));
 987                 return True;
 988
 989         } else {
 990                 int ret = get_file_version(fsp, old_file, &old_major, &old_minor);
 991                 if (ret == -1) goto error_exit;
 992
 993                 if (!ret) {
 994                         DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
 995                                          old_file));
 996                         use_version = False;
 997                         if (fsp->conn->vfs_ops.fstat(fsp, fsp->fd, &st) == -1) goto error_exit;
 998                         old_create_time = st.st_mtime;
 999                         DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n", old_create_time));
1000                 }
1001         }
1002         close_file(fsp, True);
1003
1004         /* Get file version info (if available) for new file */
1005         pstrcpy(filepath, new_file);
1006         unix_convert(filepath,conn,NULL,&bad_path,&stat_buf);
1007
1008         fsp = open_file_shared(conn, filepath, &stat_buf,
1009                                                    SET_OPEN_MODE(DOS_OPEN_RDONLY),
1010                                                    (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),
1011                                                    0, 0, &access_mode, &action);
1012         if (!fsp) {
1013                 /* New file not found, this shouldn't occur if the caller did its job */
1014                 DEBUG(3,("file_version_is_newer: Can't open new file [%s], errno = %d\n",
1015                                 filepath, errno));
1016                 goto error_exit;
1017
1018         } else {
1019                 int ret = get_file_version(fsp, new_file, &new_major, &new_minor);
1020                 if (ret == -1) goto error_exit;
1021
1022                 if (!ret) {
1023                         DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
1024                                          new_file));
1025                         use_version = False;
1026                         if (fsp->conn->vfs_ops.fstat(fsp, fsp->fd, &st) == -1) goto error_exit;
1027                         new_create_time = st.st_mtime;
1028                         DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n", new_create_time));
1029                 }
1030         }
1031         close_file(fsp, True);
1032
1033         if (use_version && (new_major != old_major || new_minor != old_minor)) {
1034                 /* Compare versions and choose the larger version number */
1035                 if (new_major > old_major ||
1036                         (new_major == old_major && new_minor > old_minor)) {
1037
1038                         DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file, new_file));
1039                         return True;
1040                 }
1041                 else {
1042                         DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file));
1043                         return False;
1044                 }
1045
1046         } else {
1047                 /* Compare modification time/dates and choose the newest time/date */
1048                 if (new_create_time > old_create_time) {
1049                         DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file, new_file));
1050                         return True;
1051                 }
1052                 else {
1053                         DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file));
1054                         return False;
1055                 }
1056         }
1057
1058         error_exit:
1059                 if(fsp)
1060                         close_file(fsp, True);
1061                 return -1;
1062 }
1063
1064 /****************************************************************************
1065 Determine the correct cVersion associated with an architecture and driver
1066 ****************************************************************************/
1067 static uint32 get_correct_cversion(fstring architecture, fstring driverpath_in,
1068                                    struct current_user *user, WERROR *perr)
1069 {
1070         int               cversion;
1071         int               access_mode;
1072         int               action;
1073         NTSTATUS          nt_status;
1074         pstring           driverpath;
1075         DATA_BLOB         null_pw;
1076         files_struct      *fsp = NULL;
1077         BOOL              bad_path;
1078         SMB_STRUCT_STAT   st;
1079         connection_struct *conn;
1080
1081         ZERO_STRUCT(st);
1082
1083         *perr = WERR_INVALID_PARAM;
1084
1085         /* If architecture is Windows 95/98/ME, the version is always 0. */
1086         if (strcmp(architecture, "WIN40") == 0) {
1087                 DEBUG(10,("get_correct_cversion: Driver is Win9x, cversion = 0\n"));
1088                 *perr = WERR_OK;
1089                 return 0;
1090         }
1091
1092         /*
1093          * Connect to the print$ share under the same account as the user connected
1094          * to the rpc pipe. Note we must still be root to do this.
1095          */
1096
1097         /* Null password is ok - we are already an authenticated user... */
1098         null_pw = data_blob(NULL, 0);
1099         become_root();
1100         conn = make_connection_with_chdir("print$", null_pw, "A:", user->vuid, &nt_status);
1101         unbecome_root();
1102
1103         if (conn == NULL) {
1104                 DEBUG(0,("get_correct_cversion: Unable to connect\n"));
1105                 *perr = ntstatus_to_werror(nt_status);
1106                 return -1;
1107         }
1108
1109         /* We are temporarily becoming the connection user. */
1110         if (!become_user(conn, conn->vuid)) {
1111                 DEBUG(0,("get_correct_cversion: Can't become user!\n"));
1112                 *perr = WERR_ACCESS_DENIED;
1113                 return -1;
1114         }
1115
1116         /* Open the driver file (Portable Executable format) and determine the
1117          * deriver the cversion. */
1118         slprintf(driverpath, sizeof(driverpath)-1, "%s/%s", architecture, driverpath_in);
1119
1120         unix_convert(driverpath,conn,NULL,&bad_path,&st);
1121
1122         fsp = open_file_shared(conn, driverpath, &st,
1123                                                    SET_OPEN_MODE(DOS_OPEN_RDONLY),
1124                                                    (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),
1125                                                    0, 0, &access_mode, &action);
1126         if (!fsp) {
1127                 DEBUG(3,("get_correct_cversion: Can't open file [%s], errno = %d\n",
1128                                 driverpath, errno));
1129                 *perr = WERR_ACCESS_DENIED;
1130                 goto error_exit;
1131         }
1132         else {
1133                 uint32 major;
1134                 uint32 minor;
1135                 int    ret = get_file_version(fsp, driverpath, &major, &minor);
1136                 if (ret == -1) goto error_exit;
1137
1138                 if (!ret) {
1139                         DEBUG(6,("get_correct_cversion: Version info not found [%s]\n", driverpath));
1140                         goto error_exit;
1141                 }
1142
1143                 /*
1144                  * This is a Microsoft'ism. See references in MSDN to VER_FILEVERSION
1145                  * for more details. Version in this case is not just the version of the
1146                  * file, but the version in the sense of kernal mode (2) vs. user mode
1147                  * (3) drivers. Other bits of the version fields are the version info.
1148                  * JRR 010716
1149                 */
1150                 cversion = major & 0x0000ffff;
1151                 switch (cversion) {
1152                         case 2: /* WinNT drivers */
1153                         case 3: /* Win2K drivers */
1154                                 break;
1155
1156                         default:
1157                                 DEBUG(6,("get_correct_cversion: cversion invalid [%s]  cversion = %d\n",
1158                                         driverpath, cversion));
1159                                 goto error_exit;
1160                 }
1161
1162                 DEBUG(10,("get_correct_cversion: Version info found [%s]  major = 0x%x  minor = 0x%x\n",
1163                                   driverpath, major, minor));
1164         }
1165
1166     DEBUG(10,("get_correct_cversion: Driver file [%s] cversion = %d\n",
1167                         driverpath, cversion));
1168
1169         close_file(fsp, True);
1170         close_cnum(conn, user->vuid);
1171         unbecome_user();
1172         *perr = WERR_OK;
1173         return cversion;
1174
1175
1176   error_exit:
1177
1178         if(fsp)
1179                 close_file(fsp, True);
1180
1181         close_cnum(conn, user->vuid);
1182         unbecome_user();
1183         return -1;
1184 }
1185
1186 /****************************************************************************
1187 ****************************************************************************/
1188 static WERROR clean_up_driver_struct_level_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver,
1189                                                                                          struct current_user *user)
1190 {
1191         fstring architecture;
1192         fstring new_name;
1193         char *p;
1194         int i;
1195         WERROR err;
1196
1197         /* clean up the driver name.
1198          * we can get .\driver.dll
1199          * or worse c:\windows\system\driver.dll !
1200          */
1201         /* using an intermediate string to not have overlaping memcpy()'s */
1202         if ((p = strrchr(driver->driverpath,'\\')) != NULL) {
1203                 fstrcpy(new_name, p+1);
1204                 fstrcpy(driver->driverpath, new_name);
1205         }
1206
1207         if ((p = strrchr(driver->datafile,'\\')) != NULL) {
1208                 fstrcpy(new_name, p+1);
1209                 fstrcpy(driver->datafile, new_name);
1210         }
1211
1212         if ((p = strrchr(driver->configfile,'\\')) != NULL) {
1213                 fstrcpy(new_name, p+1);
1214                 fstrcpy(driver->configfile, new_name);
1215         }
1216
1217         if ((p = strrchr(driver->helpfile,'\\')) != NULL) {
1218                 fstrcpy(new_name, p+1);
1219                 fstrcpy(driver->helpfile, new_name);
1220         }
1221
1222         if (driver->dependentfiles) {
1223                 for (i=0; *driver->dependentfiles[i]; i++) {
1224                         if ((p = strrchr(driver->dependentfiles[i],'\\')) != NULL) {
1225                                 fstrcpy(new_name, p+1);
1226                                 fstrcpy(driver->dependentfiles[i], new_name);
1227                         }
1228                 }
1229         }
1230
1231         get_short_archi(architecture, driver->environment);
1232
1233         /* jfm:7/16/2000 the client always sends the cversion=0.
1234          * The server should check which version the driver is by reading
1235          * the PE header of driver->driverpath.
1236          *
1237          * For Windows 95/98 the version is 0 (so the value sent is correct)
1238          * For Windows NT (the architecture doesn't matter)
1239          *      NT 3.1: cversion=0
1240          *      NT 3.5/3.51: cversion=1
1241          *      NT 4: cversion=2
1242          *      NT2K: cversion=3
1243          */
1244         if ((driver->cversion = get_correct_cversion( architecture,
1245                                                                         driver->driverpath, user, &err)) == -1)
1246                 return err;
1247
1248         return WERR_OK;
1249 }
1250
1251 /****************************************************************************
1252 ****************************************************************************/
1253 static WERROR clean_up_driver_struct_level_6(NT_PRINTER_DRIVER_INFO_LEVEL_6 *driver, struct current_user *user)
1254 {
1255         fstring architecture;
1256         fstring new_name;
1257         char *p;
1258         int i;
1259         WERROR err;
1260
1261         /* clean up the driver name.
1262          * we can get .\driver.dll
1263          * or worse c:\windows\system\driver.dll !
1264          */
1265         /* using an intermediate string to not have overlaping memcpy()'s */
1266         if ((p = strrchr(driver->driverpath,'\\')) != NULL) {
1267                 fstrcpy(new_name, p+1);
1268                 fstrcpy(driver->driverpath, new_name);
1269         }
1270
1271         if ((p = strrchr(driver->datafile,'\\')) != NULL) {
1272                 fstrcpy(new_name, p+1);
1273                 fstrcpy(driver->datafile, new_name);
1274         }
1275
1276         if ((p = strrchr(driver->configfile,'\\')) != NULL) {
1277                 fstrcpy(new_name, p+1);
1278                 fstrcpy(driver->configfile, new_name);
1279         }
1280
1281         if ((p = strrchr(driver->helpfile,'\\')) != NULL) {
1282                 fstrcpy(new_name, p+1);
1283                 fstrcpy(driver->helpfile, new_name);
1284         }
1285
1286         if (driver->dependentfiles) {
1287                 for (i=0; *driver->dependentfiles[i]; i++) {
1288                         if ((p = strrchr(driver->dependentfiles[i],'\\')) != NULL) {
1289                                 fstrcpy(new_name, p+1);
1290                                 fstrcpy(driver->dependentfiles[i], new_name);
1291                         }
1292                 }
1293         }
1294
1295         get_short_archi(architecture, driver->environment);
1296
1297         /* jfm:7/16/2000 the client always sends the cversion=0.
1298          * The server should check which version the driver is by reading
1299          * the PE header of driver->driverpath.
1300          *
1301          * For Windows 95/98 the version is 0 (so the value sent is correct)
1302          * For Windows NT (the architecture doesn't matter)
1303          *      NT 3.1: cversion=0
1304          *      NT 3.5/3.51: cversion=1
1305          *      NT 4: cversion=2
1306          *      NT2K: cversion=3
1307          */
1308         if ((driver->version = get_correct_cversion(architecture, driver->driverpath, user, &err)) == -1)
1309                 return err;
1310
1311         return WERR_OK;
1312 }
1313
1314 /****************************************************************************
1315 ****************************************************************************/
1316 WERROR clean_up_driver_struct(NT_PRINTER_DRIVER_INFO_LEVEL driver_abstract,
1317                                                           uint32 level, struct current_user *user)
1318 {
1319         switch (level) {
1320                 case 3:
1321                 {
1322                         NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver;
1323                         driver=driver_abstract.info_3;
1324                         return clean_up_driver_struct_level_3(driver, user);
1325                 }
1326                 case 6:
1327                 {
1328                         NT_PRINTER_DRIVER_INFO_LEVEL_6 *driver;
1329                         driver=driver_abstract.info_6;
1330                         return clean_up_driver_struct_level_6(driver, user);
1331                 }
1332                 default:
1333                         return WERR_INVALID_PARAM;
1334         }
1335 }
1336
1337 /****************************************************************************
1338  This function sucks and should be replaced. JRA.
1339 ****************************************************************************/
1340
1341 static void convert_level_6_to_level3(NT_PRINTER_DRIVER_INFO_LEVEL_3 *dst, NT_PRINTER_DRIVER_INFO_LEVEL_6 *src)
1342 {
1343     dst->cversion  = src->version;
1344
1345     fstrcpy( dst->name, src->name);
1346     fstrcpy( dst->environment, src->environment);
1347     fstrcpy( dst->driverpath, src->driverpath);
1348     fstrcpy( dst->datafile, src->datafile);
1349     fstrcpy( dst->configfile, src->configfile);
1350     fstrcpy( dst->helpfile, src->helpfile);
1351     fstrcpy( dst->monitorname, src->monitorname);
1352     fstrcpy( dst->defaultdatatype, src->defaultdatatype);
1353     dst->dependentfiles = src->dependentfiles;
1354 }
1355
1356 #if 0 /* Debugging function */
1357
1358 static char* ffmt(unsigned char *c){
1359         int i;
1360         static char ffmt_str[17];
1361
1362         for (i=0; i<16; i++) {
1363                 if ((c[i] < ' ') || (c[i] > '~'))
1364                         ffmt_str[i]='.';
1365                 else
1366                         ffmt_str[i]=c[i];
1367         }
1368     ffmt_str[16]='\0';
1369         return ffmt_str;
1370 }
1371
1372 #endif
1373
1374 /****************************************************************************
1375 ****************************************************************************/
1376 BOOL move_driver_to_download_area(NT_PRINTER_DRIVER_INFO_LEVEL driver_abstract, uint32 level,
1377                                   struct current_user *user, WERROR *perr)
1378 {
1379         NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver;
1380         NT_PRINTER_DRIVER_INFO_LEVEL_3 converted_driver;
1381         fstring architecture;
1382         pstring new_dir;
1383         pstring old_name;
1384         pstring new_name;
1385         DATA_BLOB null_pw;
1386         connection_struct *conn;
1387         NTSTATUS nt_status;
1388         pstring inbuf;
1389         pstring outbuf;
1390         int ver = 0;
1391         int i;
1392
1393         memset(inbuf, '\0', sizeof(inbuf));
1394         memset(outbuf, '\0', sizeof(outbuf));
1395         *perr = WERR_OK;
1396
1397         if (level==3)
1398                 driver=driver_abstract.info_3;
1399         else if (level==6) {
1400                 convert_level_6_to_level3(&converted_driver, driver_abstract.info_6);
1401                 driver = &converted_driver;
1402         } else {
1403                 DEBUG(0,("move_driver_to_download_area: Unknown info level (%u)\n", (unsigned int)level ));
1404                 return False;
1405         }
1406
1407         get_short_archi(architecture, driver->environment);
1408
1409         /*
1410          * Connect to the print$ share under the same account as the user connected to the rpc pipe.
1411          * Note we must be root to do this.
1412          */
1413
1414         become_root();
1415         null_pw = data_blob(NULL, 0);
1416         conn = make_connection_with_chdir("print$", null_pw, "A:", user->vuid, &nt_status);
1417         unbecome_root();
1418
1419         if (conn == NULL) {
1420                 DEBUG(0,("move_driver_to_download_area: Unable to connect\n"));
1421                 *perr = ntstatus_to_werror(nt_status);
1422                 return False;
1423         }
1424
1425         /*
1426          * Save who we are - we are temporarily becoming the connection user.
1427          */
1428
1429         if (!become_user(conn, conn->vuid)) {
1430                 DEBUG(0,("move_driver_to_download_area: Can't become user!\n"));
1431                 return False;
1432         }
1433
1434         /*
1435          * make the directories version and version\driver_name
1436          * under the architecture directory.
1437          */
1438         DEBUG(5,("Creating first directory\n"));
1439         slprintf(new_dir, sizeof(new_dir)-1, "%s/%d", architecture, driver->cversion);
1440         mkdir_internal(conn, new_dir);
1441
1442         /* For each driver file, archi\filexxx.yyy, if there is a duplicate file
1443          * listed for this driver which has already been moved, skip it (note:
1444          * drivers may list the same file name several times. Then check if the
1445          * file already exists in archi\cversion\, if so, check that the version
1446          * info (or time stamps if version info is unavailable) is newer (or the
1447          * date is later). If it is, move it to archi\cversion\filexxx.yyy.
1448          * Otherwise, delete the file.
1449          *
1450          * If a file is not moved to archi\cversion\ because of an error, all the
1451          * rest of the 'unmoved' driver files are removed from archi\. If one or
1452          * more of the driver's files was already moved to archi\cversion\, it
1453          * potentially leaves the driver in a partially updated state. Version
1454          * trauma will most likely occur if an client attempts to use any printer
1455          * bound to the driver. Perhaps a rewrite to make sure the moves can be
1456          * done is appropriate... later JRR
1457          */
1458
1459         DEBUG(5,("Moving files now !\n"));
1460
1461         if (driver->driverpath && strlen(driver->driverpath)) {
1462                 slprintf(new_name, sizeof(new_name)-1, "%s/%s", architecture, driver->driverpath);
1463                 slprintf(old_name, sizeof(old_name)-1, "%s/%s", new_dir, driver->driverpath);
1464                 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1465                         NTSTATUS status;
1466                         status = rename_internals(conn, new_name, old_name, True);
1467                         if (!NT_STATUS_IS_OK(status)) {
1468                                 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1469                                                 new_name, old_name));
1470                                 *perr = ntstatus_to_werror(status);
1471                                 unlink_internals(conn, 0, new_name);
1472                                 ver = -1;
1473                         }
1474                 }
1475                 else
1476                         unlink_internals(conn, 0, new_name);
1477         }
1478
1479         if (driver->datafile && strlen(driver->datafile)) {
1480                 if (!strequal(driver->datafile, driver->driverpath)) {
1481                         slprintf(new_name, sizeof(new_name)-1, "%s/%s", architecture, driver->datafile);
1482                         slprintf(old_name, sizeof(old_name)-1, "%s/%s", new_dir, driver->datafile);
1483                         if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1484                                 NTSTATUS status;
1485                                 status = rename_internals(conn, new_name, old_name, True);
1486                                 if (!NT_STATUS_IS_OK(status)) {
1487                                         DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1488                                                         new_name, old_name));
1489                                         *perr = ntstatus_to_werror(status);
1490                                         unlink_internals(conn, 0, new_name);
1491                                         ver = -1;
1492                                 }
1493                         }
1494                         else
1495                                 unlink_internals(conn, 0, new_name);
1496                 }
1497         }
1498
1499         if (driver->configfile && strlen(driver->configfile)) {
1500                 if (!strequal(driver->configfile, driver->driverpath) &&
1501                         !strequal(driver->configfile, driver->datafile)) {
1502                         slprintf(new_name, sizeof(new_name)-1, "%s/%s", architecture, driver->configfile);
1503                         slprintf(old_name, sizeof(old_name)-1, "%s/%s", new_dir, driver->configfile);
1504                         if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1505                                 NTSTATUS status;
1506                                 status = rename_internals(conn, new_name, old_name, True);
1507                                 if (!NT_STATUS_IS_OK(status)) {
1508                                         DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1509                                                         new_name, old_name));
1510                                         *perr = ntstatus_to_werror(status);
1511                                         unlink_internals(conn, 0, new_name);
1512                                         ver = -1;
1513                                 }
1514                         }
1515                         else
1516                                 unlink_internals(conn, 0, new_name);
1517                 }
1518         }
1519
1520         if (driver->helpfile && strlen(driver->helpfile)) {
1521                 if (!strequal(driver->helpfile, driver->driverpath) &&
1522                         !strequal(driver->helpfile, driver->datafile) &&
1523                         !strequal(driver->helpfile, driver->configfile)) {
1524                         slprintf(new_name, sizeof(new_name)-1, "%s/%s", architecture, driver->helpfile);
1525                         slprintf(old_name, sizeof(old_name)-1, "%s/%s", new_dir, driver->helpfile);
1526                         if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1527                                 NTSTATUS status;
1528                                 status = rename_internals(conn, new_name, old_name, True);
1529                                 if (!NT_STATUS_IS_OK(status)) {
1530                                         DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1531                                                         new_name, old_name));
1532                                         *perr = ntstatus_to_werror(status);
1533                                         unlink_internals(conn, 0, new_name);
1534                                         ver = -1;
1535                                 }
1536                         }
1537                         else
1538                                 unlink_internals(conn, 0, new_name);
1539                 }
1540         }
1541
1542         if (driver->dependentfiles) {
1543                 for (i=0; *driver->dependentfiles[i]; i++) {
1544                         if (!strequal(driver->dependentfiles[i], driver->driverpath) &&
1545                                 !strequal(driver->dependentfiles[i], driver->datafile) &&
1546                                 !strequal(driver->dependentfiles[i], driver->configfile) &&
1547                                 !strequal(driver->dependentfiles[i], driver->helpfile)) {
1548                                 int j;
1549                                 for (j=0; j < i; j++) {
1550                                         if (strequal(driver->dependentfiles[i], driver->dependentfiles[j])) {
1551                                                 goto NextDriver;
1552                                         }
1553                                 }
1554
1555                                 slprintf(new_name, sizeof(new_name)-1, "%s/%s", architecture, driver->dependentfiles[i]);
1556                                 slprintf(old_name, sizeof(old_name)-1, "%s/%s", new_dir, driver->dependentfiles[i]);
1557                                 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1558                                         NTSTATUS status;
1559                                         status = rename_internals(conn, new_name, old_name, True);
1560                                         if (!NT_STATUS_IS_OK(status)) {
1561                                                 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1562                                                                 new_name, old_name));
1563                                                 *perr = ntstatus_to_werror(status);
1564                                                 unlink_internals(conn, 0, new_name);
1565                                                 ver = -1;
1566                                         }
1567                                 }
1568                                 else
1569                                         unlink_internals(conn, 0, new_name);
1570                         }
1571                 NextDriver: ;
1572                 }
1573         }
1574
1575         close_cnum(conn, user->vuid);
1576         unbecome_user();
1577
1578         return ver == -1 ? False : True;
1579 }
1580
1581 /****************************************************************************
1582 ****************************************************************************/
1583 static uint32 add_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver)
1584 {
1585         int len, buflen;
1586         fstring architecture;
1587         pstring directory;
1588         pstring temp_name;
1589         pstring key;
1590         char *buf;
1591         int i, ret;
1592         TDB_DATA kbuf, dbuf;
1593
1594         get_short_archi(architecture, driver->environment);
1595
1596         /* The names are relative. We store them in the form: \print$\arch\version\driver.xxx
1597          * \\server is added in the rpc server layer.
1598          * It does make sense to NOT store the server's name in the printer TDB.
1599          */
1600
1601         slprintf(directory, sizeof(directory)-1, "\\print$\\%s\\%d\\", architecture, driver->cversion);
1602
1603         /* .inf files do not always list a file for each of the four standard files.
1604          * Don't prepend a path to a null filename, or client claims:
1605          *   "The server on which the printer resides does not have a suitable
1606          *   <printer driver name> printer driver installed. Click OK if you
1607          *   wish to install the driver on your local machine."
1608          */
1609         if (strlen(driver->driverpath)) {
1610                 fstrcpy(temp_name, driver->driverpath);
1611                 slprintf(driver->driverpath, sizeof(driver->driverpath)-1, "%s%s", directory, temp_name);
1612         }
1613
1614         if (strlen(driver->datafile)) {
1615                 fstrcpy(temp_name, driver->datafile);
1616                 slprintf(driver->datafile, sizeof(driver->datafile)-1, "%s%s", directory, temp_name);
1617         }
1618
1619         if (strlen(driver->configfile)) {
1620                 fstrcpy(temp_name, driver->configfile);
1621                 slprintf(driver->configfile, sizeof(driver->configfile)-1, "%s%s", directory, temp_name);
1622         }
1623
1624         if (strlen(driver->helpfile)) {
1625                 fstrcpy(temp_name, driver->helpfile);
1626                 slprintf(driver->helpfile, sizeof(driver->helpfile)-1, "%s%s", directory, temp_name);
1627         }
1628
1629         if (driver->dependentfiles) {
1630                 for (i=0; *driver->dependentfiles[i]; i++) {
1631                         fstrcpy(temp_name, driver->dependentfiles[i]);
1632                         slprintf(driver->dependentfiles[i], sizeof(driver->dependentfiles[i])-1, "%s%s", directory, temp_name);
1633                 }
1634         }
1635
1636         slprintf(key, sizeof(key)-1, "%s%s/%d/%s", DRIVERS_PREFIX, architecture, driver->cversion, driver->name);
1637
1638         DEBUG(5,("add_a_printer_driver_3: Adding driver with key %s\n", key ));
1639
1640         buf = NULL;
1641         len = buflen = 0;
1642
1643  again:
1644         len = 0;
1645         len += tdb_pack(buf+len, buflen-len, "dffffffff",
1646                         driver->cversion,
1647                         driver->name,
1648                         driver->environment,
1649                         driver->driverpath,
1650                         driver->datafile,
1651                         driver->configfile,
1652                         driver->helpfile,
1653                         driver->monitorname,
1654                         driver->defaultdatatype);
1655
1656         if (driver->dependentfiles) {
1657                 for (i=0; *driver->dependentfiles[i]; i++) {
1658                         len += tdb_pack(buf+len, buflen-len, "f",
1659                                         driver->dependentfiles[i]);
1660                 }
1661         }
1662
1663         if (len != buflen) {
1664                 char *tb;
1665
1666                 tb = (char *)Realloc(buf, len);
1667                 if (!tb) {
1668                         DEBUG(0,("add_a_printer_driver_3: failed to enlarge buffer\n!"));
1669                         ret = -1;
1670                         goto done;
1671                 }
1672                 else buf = tb;
1673                 buflen = len;
1674                 goto again;
1675         }
1676
1677
1678         kbuf.dptr = key;
1679         kbuf.dsize = strlen(key)+1;
1680         dbuf.dptr = buf;
1681         dbuf.dsize = len;
1682
1683         ret = tdb_store(tdb_drivers, kbuf, dbuf, TDB_REPLACE);
1684
1685 done:
1686         if (ret)
1687                 DEBUG(0,("add_a_printer_driver_3: Adding driver with key %s failed.\n", key ));
1688
1689         SAFE_FREE(buf);
1690         return ret;
1691 }
1692
1693 /****************************************************************************
1694 ****************************************************************************/
1695 static uint32 add_a_printer_driver_6(NT_PRINTER_DRIVER_INFO_LEVEL_6 *driver)
1696 {
1697         NT_PRINTER_DRIVER_INFO_LEVEL_3 info3;
1698
1699         ZERO_STRUCT(info3);
1700         info3.cversion = driver->version;
1701         fstrcpy(info3.name,driver->name);
1702         fstrcpy(info3.environment,driver->environment);
1703         fstrcpy(info3.driverpath,driver->driverpath);
1704         fstrcpy(info3.datafile,driver->datafile);
1705         fstrcpy(info3.configfile,driver->configfile);
1706         fstrcpy(info3.helpfile,driver->helpfile);
1707         fstrcpy(info3.monitorname,driver->monitorname);
1708         fstrcpy(info3.defaultdatatype,driver->defaultdatatype);
1709         info3.dependentfiles = driver->dependentfiles;
1710
1711         return add_a_printer_driver_3(&info3);
1712 }
1713
1714
1715 /****************************************************************************
1716 ****************************************************************************/
1717 static WERROR get_a_printer_driver_3_default(NT_PRINTER_DRIVER_INFO_LEVEL_3 **info_ptr, fstring driver, fstring arch)
1718 {
1719         NT_PRINTER_DRIVER_INFO_LEVEL_3 info;
1720
1721         ZERO_STRUCT(info);
1722
1723         fstrcpy(info.name, driver);
1724         fstrcpy(info.defaultdatatype, "RAW");
1725
1726         fstrcpy(info.driverpath, "");
1727         fstrcpy(info.datafile, "");
1728         fstrcpy(info.configfile, "");
1729         fstrcpy(info.helpfile, "");
1730
1731         if ((info.dependentfiles=(fstring *)malloc(2*sizeof(fstring))) == NULL)
1732                 return WERR_NOMEM;
1733
1734         memset(info.dependentfiles, '\0', 2*sizeof(fstring));
1735         fstrcpy(info.dependentfiles[0], "");
1736
1737         *info_ptr = memdup(&info, sizeof(info));
1738
1739         return WERR_OK;
1740 }
1741
1742 /****************************************************************************
1743 ****************************************************************************/
1744 static WERROR get_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 **info_ptr, fstring drivername, fstring arch, uint32 version)
1745 {
1746         NT_PRINTER_DRIVER_INFO_LEVEL_3 driver;
1747         TDB_DATA kbuf, dbuf;
1748         fstring architecture;
1749         int len = 0;
1750         int i;
1751         pstring key;
1752
1753         ZERO_STRUCT(driver);
1754
1755         get_short_archi(architecture, arch);
1756
1757         DEBUG(8,("get_a_printer_driver_3: [%s%s/%d/%s]\n", DRIVERS_PREFIX, architecture, version, drivername));
1758
1759         slprintf(key, sizeof(key)-1, "%s%s/%d/%s", DRIVERS_PREFIX, architecture, version, drivername);
1760
1761         kbuf.dptr = key;
1762         kbuf.dsize = strlen(key)+1;
1763
1764         dbuf = tdb_fetch(tdb_drivers, kbuf);
1765         if (!dbuf.dptr)
1766                 return WERR_UNKNOWN_PRINTER_DRIVER;
1767
1768         len += tdb_unpack(dbuf.dptr, dbuf.dsize, "dffffffff",
1769                           &driver.cversion,
1770                           driver.name,
1771                           driver.environment,
1772                           driver.driverpath,
1773                           driver.datafile,
1774                           driver.configfile,
1775                           driver.helpfile,
1776                           driver.monitorname,
1777                           driver.defaultdatatype);
1778
1779         i=0;
1780         while (len < dbuf.dsize) {
1781                 fstring *tddfs;
1782
1783                 tddfs = (fstring *)Realloc(driver.dependentfiles,
1784                                                          sizeof(fstring)*(i+2));
1785                 if (tddfs == NULL) {
1786                         DEBUG(0,("get_a_printer_driver_3: failed to enlarge buffer!\n"));
1787                         break;
1788                 }
1789                 else driver.dependentfiles = tddfs;
1790
1791                 len += tdb_unpack(dbuf.dptr+len, dbuf.dsize-len, "f",
1792                                   &driver.dependentfiles[i]);
1793                 i++;
1794         }
1795
1796         if (driver.dependentfiles != NULL)
1797                 fstrcpy(driver.dependentfiles[i], "");
1798
1799         SAFE_FREE(dbuf.dptr);
1800
1801         if (len != dbuf.dsize) {
1802                 SAFE_FREE(driver.dependentfiles);
1803
1804                 return get_a_printer_driver_3_default(info_ptr, drivername, arch);
1805         }
1806
1807         *info_ptr = (NT_PRINTER_DRIVER_INFO_LEVEL_3 *)memdup(&driver, sizeof(driver));
1808
1809         return WERR_OK;
1810 }
1811
1812 /****************************************************************************
1813  Debugging function, dump at level 6 the struct in the logs.
1814 ****************************************************************************/
1815
1816 static uint32 dump_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
1817 {
1818         uint32 result;
1819         NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3;
1820         int i;
1821
1822         DEBUG(20,("Dumping printer driver at level [%d]\n", level));
1823
1824         switch (level)
1825         {
1826                 case 3:
1827                 {
1828                         if (driver.info_3 == NULL)
1829                                 result=5;
1830                         else {
1831                                 info3=driver.info_3;
1832
1833                                 DEBUGADD(20,("version:[%d]\n",         info3->cversion));
1834                                 DEBUGADD(20,("name:[%s]\n",            info3->name));
1835                                 DEBUGADD(20,("environment:[%s]\n",     info3->environment));
1836                                 DEBUGADD(20,("driverpath:[%s]\n",      info3->driverpath));
1837                                 DEBUGADD(20,("datafile:[%s]\n",        info3->datafile));
1838                                 DEBUGADD(20,("configfile:[%s]\n",      info3->configfile));
1839                                 DEBUGADD(20,("helpfile:[%s]\n",        info3->helpfile));
1840                                 DEBUGADD(20,("monitorname:[%s]\n",     info3->monitorname));
1841                                 DEBUGADD(20,("defaultdatatype:[%s]\n", info3->defaultdatatype));
1842
1843                                 for (i=0; info3->dependentfiles &&
1844                                           *info3->dependentfiles[i]; i++) {
1845                                         DEBUGADD(20,("dependentfile:[%s]\n",
1846                                                       info3->dependentfiles[i]));
1847                                 }
1848                                 result=0;
1849                         }
1850                         break;
1851                 }
1852                 default:
1853                         DEBUGADD(20,("dump_a_printer_driver: Level %u not implemented\n", (unsigned int)level));
1854                         result=1;
1855                         break;
1856         }
1857
1858         return result;
1859 }
1860
1861 /****************************************************************************
1862 ****************************************************************************/
1863 int pack_devicemode(NT_DEVICEMODE *nt_devmode, char *buf, int buflen)
1864 {
1865         int len = 0;
1866
1867         len += tdb_pack(buf+len, buflen-len, "p", nt_devmode);
1868
1869         if (!nt_devmode) return len;
1870
1871         len += tdb_pack(buf+len, buflen-len, "ffwwwwwwwwwwwwwwwwwwddddddddddddddp",
1872                         nt_devmode->devicename,
1873                         nt_devmode->formname,
1874
1875                         nt_devmode->specversion,
1876                         nt_devmode->driverversion,
1877                         nt_devmode->size,
1878                         nt_devmode->driverextra,
1879                         nt_devmode->orientation,
1880                         nt_devmode->papersize,
1881                         nt_devmode->paperlength,
1882                         nt_devmode->paperwidth,
1883                         nt_devmode->scale,
1884                         nt_devmode->copies,
1885                         nt_devmode->defaultsource,
1886                         nt_devmode->printquality,
1887                         nt_devmode->color,
1888                         nt_devmode->duplex,
1889                         nt_devmode->yresolution,
1890                         nt_devmode->ttoption,
1891                         nt_devmode->collate,
1892                         nt_devmode->logpixels,
1893
1894                         nt_devmode->fields,
1895                         nt_devmode->bitsperpel,
1896                         nt_devmode->pelswidth,
1897                         nt_devmode->pelsheight,
1898                         nt_devmode->displayflags,
1899                         nt_devmode->displayfrequency,
1900                         nt_devmode->icmmethod,
1901                         nt_devmode->icmintent,
1902                         nt_devmode->mediatype,
1903                         nt_devmode->dithertype,
1904                         nt_devmode->reserved1,
1905                         nt_devmode->reserved2,
1906                         nt_devmode->panningwidth,
1907                         nt_devmode->panningheight,
1908                         nt_devmode->private);
1909
1910
1911         if (nt_devmode->private) {
1912                 len += tdb_pack(buf+len, buflen-len, "B",
1913                                 nt_devmode->driverextra,
1914                                 nt_devmode->private);
1915         }
1916
1917         DEBUG(8,("Packed devicemode [%s]\n", nt_devmode->formname));
1918
1919         return len;
1920 }
1921
1922 /****************************************************************************
1923  Pack all values in all printer keys
1924  ***************************************************************************/
1925
1926 static int pack_values(NT_PRINTER_DATA *data, char *buf, int buflen)
1927 {
1928         int             len = 0;
1929         int             i, j;
1930         REGISTRY_VALUE  *val;
1931         REGVAL_CTR      *val_ctr;
1932         pstring         path;
1933         int             num_values;
1934
1935         if ( !data )
1936                 return 0;
1937
1938         /* loop over all keys */
1939
1940         for ( i=0; i<data->num_keys; i++ )
1941         {
1942                 val_ctr = &data->keys[i].values;
1943                 num_values = regval_ctr_numvals( val_ctr );
1944
1945                 /* loop over all values */
1946
1947                 for ( j=0; j<num_values; j++ )
1948                 {
1949                         /* pathname should be stored as <key>\<value> */
1950
1951                         val = regval_ctr_specific_value( val_ctr, j );
1952                         pstrcpy( path, data->keys[i].name );
1953                         pstrcat( path, "\\" );
1954                         pstrcat( path, regval_name(val) );
1955
1956                         len += tdb_pack(buf+len, buflen-len, "pPdB",
1957                                         val,
1958                                         path,
1959                                         regval_type(val),
1960                                         regval_size(val),
1961                                         regval_data_p(val) );
1962                 }
1963
1964         }
1965
1966         /* terminator */
1967
1968         len += tdb_pack(buf+len, buflen-len, "p", NULL);
1969
1970         return len;
1971 }
1972
1973
1974 /****************************************************************************
1975  Delete a printer - this just deletes the printer info file, any open
1976  handles are not affected.
1977 ****************************************************************************/
1978
1979 uint32 del_a_printer(char *sharename)
1980 {
1981         pstring key;
1982         TDB_DATA kbuf;
1983
1984         slprintf(key, sizeof(key)-1, "%s%s", PRINTERS_PREFIX, sharename);
1985
1986         kbuf.dptr=key;
1987         kbuf.dsize=strlen(key)+1;
1988
1989         tdb_delete(tdb_printers, kbuf);
1990         return 0;
1991 }
1992
1993 /* FIXME!!!  Reorder so this forward declaration is not necessary --jerry */
1994 static WERROR get_a_printer_2(NT_PRINTER_INFO_LEVEL_2 **, fstring);
1995 static void free_nt_printer_info_level_2(NT_PRINTER_INFO_LEVEL_2 **);
1996 /****************************************************************************
1997 ****************************************************************************/
1998 static WERROR update_a_printer_2(NT_PRINTER_INFO_LEVEL_2 *info)
1999 {
2000         pstring key;
2001         char *buf;
2002         int buflen, len;
2003         WERROR ret;
2004         TDB_DATA kbuf, dbuf;
2005
2006         /*
2007          * in addprinter: no servername and the printer is the name
2008          * in setprinter: servername is \\server
2009          *                and printer is \\server\\printer
2010          *
2011          * Samba manages only local printers.
2012          * we currently don't support things like path=\\other_server\printer
2013          */
2014
2015         if (info->servername[0]!='\0') {
2016                 trim_string(info->printername, info->servername, NULL);
2017                 trim_string(info->printername, "\\", NULL);
2018                 info->servername[0]='\0';
2019         }
2020
2021         /*
2022          * JFM: one day I'll forget.
2023          * below that's info->portname because that's the SAMBA sharename
2024          * and I made NT 'thinks' it's the portname
2025          * the info->sharename is the thing you can name when you add a printer
2026          * that's the short-name when you create shared printer for 95/98
2027          * So I've made a limitation in SAMBA: you can only have 1 printer model
2028          * behind a SAMBA share.
2029          */
2030
2031         buf = NULL;
2032         buflen = 0;
2033
2034  again:
2035         len = 0;
2036         len += tdb_pack(buf+len, buflen-len, "dddddddddddfffffPfffff",
2037                         info->attributes,
2038                         info->priority,
2039                         info->default_priority,
2040                         info->starttime,
2041                         info->untiltime,
2042                         info->status,
2043                         info->cjobs,
2044                         info->averageppm,
2045                         info->changeid,
2046                         info->c_setprinter,
2047                         info->setuptime,
2048                         info->servername,
2049                         info->printername,
2050                         info->sharename,
2051                         info->portname,
2052                         info->drivername,
2053                         info->comment,
2054                         info->location,
2055                         info->sepfile,
2056                         info->printprocessor,
2057                         info->datatype,
2058                         info->parameters);
2059
2060         len += pack_devicemode(info->devmode, buf+len, buflen-len);
2061
2062         len += pack_values( &info->data, buf+len, buflen-len );
2063
2064         if (buflen != len) {
2065                 char *tb;
2066
2067                 tb = (char *)Realloc(buf, len);
2068                 if (!tb) {
2069                         DEBUG(0,("update_a_printer_2: failed to enlarge buffer!\n"));
2070                         ret = WERR_NOMEM;
2071                         goto done;
2072                 }
2073                 else buf = tb;
2074                 buflen = len;
2075                 goto again;
2076         }
2077
2078
2079         slprintf(key, sizeof(key)-1, "%s%s", PRINTERS_PREFIX, info->sharename);
2080
2081         kbuf.dptr = key;
2082         kbuf.dsize = strlen(key)+1;
2083         dbuf.dptr = buf;
2084         dbuf.dsize = len;
2085
2086         ret = (tdb_store(tdb_printers, kbuf, dbuf, TDB_REPLACE) == 0? WERR_OK : WERR_NOMEM);
2087
2088 done:
2089         if (!W_ERROR_IS_OK(ret))
2090                 DEBUG(8, ("error updating printer to tdb on disk\n"));
2091
2092         SAFE_FREE(buf);
2093
2094         DEBUG(8,("packed printer [%s] with driver [%s] portname=[%s] len=%d\n",
2095                  info->sharename, info->drivername, info->portname, len));
2096
2097         return ret;
2098 }
2099
2100
2101 /****************************************************************************
2102  Malloc and return an NT devicemode.
2103 ****************************************************************************/
2104
2105 NT_DEVICEMODE *construct_nt_devicemode(const fstring default_devicename)
2106 {
2107
2108         char adevice[32];
2109         NT_DEVICEMODE *nt_devmode = (NT_DEVICEMODE *)malloc(sizeof(NT_DEVICEMODE));
2110
2111         if (nt_devmode == NULL) {
2112                 DEBUG(0,("construct_nt_devicemode: malloc fail.\n"));
2113                 return NULL;
2114         }
2115
2116         ZERO_STRUCTP(nt_devmode);
2117
2118         safe_strcpy(adevice, default_devicename, sizeof(adevice));
2119         fstrcpy(nt_devmode->devicename, adevice);
2120
2121         fstrcpy(nt_devmode->formname, "Letter");
2122
2123         nt_devmode->specversion      = 0x0401;
2124         nt_devmode->driverversion    = 0x0400;
2125         nt_devmode->size             = 0x00DC;
2126         nt_devmode->driverextra      = 0x0000;
2127         nt_devmode->fields           = FORMNAME | TTOPTION | PRINTQUALITY |
2128                                        DEFAULTSOURCE | COPIES | SCALE |
2129                                        PAPERSIZE | ORIENTATION;
2130         nt_devmode->orientation      = 1;
2131         nt_devmode->papersize        = PAPER_LETTER;
2132         nt_devmode->paperlength      = 0;
2133         nt_devmode->paperwidth       = 0;
2134         nt_devmode->scale            = 0x64;
2135         nt_devmode->copies           = 1;
2136         nt_devmode->defaultsource    = BIN_FORMSOURCE;
2137         nt_devmode->printquality     = RES_HIGH;           /* 0x0258 */
2138         nt_devmode->color            = COLOR_MONOCHROME;
2139         nt_devmode->duplex           = DUP_SIMPLEX;
2140         nt_devmode->yresolution      = 0;
2141         nt_devmode->ttoption         = TT_SUBDEV;
2142         nt_devmode->collate          = COLLATE_FALSE;
2143         nt_devmode->icmmethod        = 0;
2144         nt_devmode->icmintent        = 0;
2145         nt_devmode->mediatype        = 0;
2146         nt_devmode->dithertype       = 0;
2147
2148         /* non utilisés par un driver d'imprimante */
2149         nt_devmode->logpixels        = 0;
2150         nt_devmode->bitsperpel       = 0;
2151         nt_devmode->pelswidth        = 0;
2152         nt_devmode->pelsheight       = 0;
2153         nt_devmode->displayflags     = 0;
2154         nt_devmode->displayfrequency = 0;
2155         nt_devmode->reserved1        = 0;
2156         nt_devmode->reserved2        = 0;
2157         nt_devmode->panningwidth     = 0;
2158         nt_devmode->panningheight    = 0;
2159
2160         nt_devmode->private = NULL;
2161         return nt_devmode;
2162 }
2163
2164 /****************************************************************************
2165  Deepcopy an NT devicemode.
2166 ****************************************************************************/
2167
2168 NT_DEVICEMODE *dup_nt_devicemode(NT_DEVICEMODE *nt_devicemode)
2169 {
2170         NT_DEVICEMODE *new_nt_devicemode = NULL;
2171
2172         if ((new_nt_devicemode = (NT_DEVICEMODE *)memdup(nt_devicemode, sizeof(NT_DEVICEMODE))) == NULL) {
2173                 DEBUG(0,("dup_nt_devicemode: malloc fail.\n"));
2174                 return NULL;
2175         }
2176
2177         new_nt_devicemode->private = NULL;
2178         if (nt_devicemode->private != NULL) {
2179                 if ((new_nt_devicemode->private = memdup(nt_devicemode->private, nt_devicemode->driverextra)) == NULL) {
2180                         SAFE_FREE(new_nt_devicemode);
2181                         DEBUG(0,("dup_nt_devicemode: malloc fail.\n"));
2182                         return NULL;
2183         }
2184         }
2185
2186         return new_nt_devicemode;
2187 }
2188
2189 /****************************************************************************
2190  Clean up and deallocate a (maybe partially) allocated NT_DEVICEMODE.
2191 ****************************************************************************/
2192
2193 void free_nt_devicemode(NT_DEVICEMODE **devmode_ptr)
2194 {
2195         NT_DEVICEMODE *nt_devmode = *devmode_ptr;
2196
2197         if(nt_devmode == NULL)
2198                 return;
2199
2200         DEBUG(106,("free_nt_devicemode: deleting DEVMODE\n"));
2201
2202         SAFE_FREE(nt_devmode->private);
2203         SAFE_FREE(*devmode_ptr);
2204 }
2205
2206 /****************************************************************************
2207  Clean up and deallocate a (maybe partially) allocated NT_PRINTER_INFO_LEVEL_2.
2208 ****************************************************************************/
2209 static void free_nt_printer_info_level_2(NT_PRINTER_INFO_LEVEL_2 **info_ptr)
2210 {
2211         NT_PRINTER_INFO_LEVEL_2 *info = *info_ptr;
2212         NT_PRINTER_DATA         *data;
2213         int                     i;
2214
2215         if ( !info )
2216                 return;
2217
2218         DEBUG(106,("free_nt_printer_info_level_2: deleting info\n"));
2219
2220         free_nt_devicemode(&info->devmode);
2221
2222         /* clean up all registry keys */
2223
2224         data = &info->data;
2225         for ( i=0; i<data->num_keys; i++ )
2226         {
2227                 SAFE_FREE( data->keys[i].name );
2228                 regval_ctr_destroy( &data->keys[i].values );
2229         }
2230         SAFE_FREE( data->keys );
2231
2232         /* finally the top level structure */
2233
2234         SAFE_FREE( *info_ptr );
2235 }
2236
2237
2238 /****************************************************************************
2239 ****************************************************************************/
2240 int unpack_devicemode(NT_DEVICEMODE **nt_devmode, char *buf, int buflen)
2241 {
2242         int len = 0;
2243         int extra_len = 0;
2244         NT_DEVICEMODE devmode;
2245
2246         ZERO_STRUCT(devmode);
2247
2248         len += tdb_unpack(buf+len, buflen-len, "p", nt_devmode);
2249
2250         if (!*nt_devmode) return len;
2251
2252         len += tdb_unpack(buf+len, buflen-len, "ffwwwwwwwwwwwwwwwwwwddddddddddddddp",
2253                           devmode.devicename,
2254                           devmode.formname,
2255
2256                           &devmode.specversion,
2257                           &devmode.driverversion,
2258                           &devmode.size,
2259                           &devmode.driverextra,
2260                           &devmode.orientation,
2261                           &devmode.papersize,
2262                           &devmode.paperlength,
2263                           &devmode.paperwidth,
2264                           &devmode.scale,
2265                           &devmode.copies,
2266                           &devmode.defaultsource,
2267                           &devmode.printquality,
2268                           &devmode.color,
2269                           &devmode.duplex,
2270                           &devmode.yresolution,
2271                           &devmode.ttoption,
2272                           &devmode.collate,
2273                           &devmode.logpixels,
2274
2275                           &devmode.fields,
2276                           &devmode.bitsperpel,
2277                           &devmode.pelswidth,
2278                           &devmode.pelsheight,
2279                           &devmode.displayflags,
2280                           &devmode.displayfrequency,
2281                           &devmode.icmmethod,
2282                           &devmode.icmintent,
2283                           &devmode.mediatype,
2284                           &devmode.dithertype,
2285                           &devmode.reserved1,
2286                           &devmode.reserved2,
2287                           &devmode.panningwidth,
2288                           &devmode.panningheight,
2289                           &devmode.private);
2290
2291         if (devmode.private) {
2292                 /* the len in tdb_unpack is an int value and
2293                  * devmode.driverextra is only a short
2294                  */
2295                 len += tdb_unpack(buf+len, buflen-len, "B", &extra_len, &devmode.private);
2296                 devmode.driverextra=(uint16)extra_len;
2297
2298                 /* check to catch an invalid TDB entry so we don't segfault */
2299                 if (devmode.driverextra == 0) {
2300                         devmode.private = NULL;
2301                 }
2302         }
2303
2304         *nt_devmode = (NT_DEVICEMODE *)memdup(&devmode, sizeof(devmode));
2305
2306         DEBUG(8,("Unpacked devicemode [%s](%s)\n", devmode.devicename, devmode.formname));
2307         if (devmode.private)
2308                 DEBUG(8,("with a private section of %d bytes\n", devmode.driverextra));
2309
2310         return len;
2311 }
2312
2313 /****************************************************************************
2314  allocate and initialize a new slot in
2315  ***************************************************************************/
2316
2317 static int add_new_printer_key( NT_PRINTER_DATA *data, char *name )
2318 {
2319         NT_PRINTER_KEY  *d;
2320         int             key_index;
2321
2322         if ( !data || !name )
2323                 return -1;
2324
2325         /* allocate another slot in the NT_PRINTER_KEY array */
2326
2327         d = Realloc( data->keys, sizeof(NT_PRINTER_KEY)*(data->num_keys+1) );
2328         if ( d )
2329                 data->keys = d;
2330
2331         key_index = data->num_keys;
2332
2333         /* initialze new key */
2334
2335         data->num_keys++;
2336         data->keys[key_index].name = strdup( name );
2337
2338         ZERO_STRUCTP( &data->keys[key_index].values );
2339
2340         regval_ctr_init( &data->keys[key_index].values );
2341
2342         DEBUG(10,("add_new_printer_key: Inserted new data key [%s]\n", name ));
2343
2344         return key_index;
2345 }
2346
2347 /****************************************************************************
2348  search for a registry key name in the existing printer data
2349  ***************************************************************************/
2350
2351 int lookup_printerkey( NT_PRINTER_DATA *data, char *name )
2352 {
2353         int             key_index = -1;
2354         int             i;
2355
2356         if ( !data || !name )
2357                 return -1;
2358
2359         DEBUG(12,("lookup_printerkey: Looking for [%s]\n", name));
2360
2361         /* loop over all existing keys */
2362
2363         for ( i=0; i<data->num_keys; i++ )
2364         {
2365                 if ( strequal(data->keys[i].name, name) ) {
2366                         DEBUG(12,("lookup_printerkey: Found [%s]!\n", name));
2367                         key_index = i;
2368                         break;
2369
2370                 }
2371         }
2372
2373         return key_index;
2374 }
2375
2376 /****************************************************************************
2377  ***************************************************************************/
2378
2379 uint32 get_printer_subkeys( NT_PRINTER_DATA *data, char* key, fstring **subkeys )
2380 {
2381         int     i, j;
2382         int     key_len;
2383         int     num_subkeys = 0;
2384         char    *p;
2385         fstring *ptr, *subkeys_ptr = NULL;
2386         fstring subkeyname;
2387
2388         if ( !data )
2389                 return 0;
2390
2391         for ( i=0; i<data->num_keys; i++ )
2392         {
2393                 if ( StrnCaseCmp(data->keys[i].name, key, strlen(key)) == 0 )
2394                 {
2395                         /* match sure it is a subkey and not the key itself */
2396
2397                         key_len = strlen( key );
2398                         if ( strlen(data->keys[i].name) == key_len )
2399                                 continue;
2400
2401                         /* get subkey path */
2402
2403                         p = data->keys[i].name + key_len;
2404                         if ( *p == '\\' )
2405                                 p++;
2406                         fstrcpy( subkeyname, p );
2407                         if ( (p = strchr( subkeyname, '\\' )) )
2408                                 *p = '\0';
2409
2410                         /* don't add a key more than once */
2411
2412                         for ( j=0; j<num_subkeys; j++ ) {
2413                                 if ( strequal( subkeys_ptr[j], subkeyname ) )
2414                                         break;
2415                         }
2416
2417                         if ( j != num_subkeys )
2418                                 continue;
2419
2420                         /* found a match, so allocate space and copy the name */
2421
2422                         if ( !(ptr = Realloc( subkeys_ptr, (num_subkeys+2)*sizeof(fstring))) ) {
2423                                 DEBUG(0,("get_printer_subkeys: Realloc failed for [%d] entries!\n",
2424                                         num_subkeys+1));
2425                                 SAFE_FREE( subkeys );
2426                                 return 0;
2427                         }
2428
2429                         subkeys_ptr = ptr;
2430                         fstrcpy( subkeys_ptr[num_subkeys], subkeyname );
2431                         num_subkeys++;
2432                 }
2433
2434         }
2435
2436         /* tag of the end */
2437
2438         if (num_subkeys)
2439                 fstrcpy( subkeys_ptr[num_subkeys], "" );
2440
2441         *subkeys = subkeys_ptr;
2442
2443         return num_subkeys;
2444 }
2445
2446 static void map_sz_into_ctr(REGVAL_CTR *ctr, const char *val_name,
2447                             const char *sz)
2448 {
2449         smb_ucs2_t conv_str[1024];
2450         size_t str_size;
2451
2452         regval_ctr_delvalue(ctr, val_name);
2453         str_size = push_ucs2(NULL, conv_str, sz, sizeof(conv_str),
2454                              STR_TERMINATE | STR_NOALIGN);
2455         regval_ctr_addvalue(ctr, val_name, REG_SZ,
2456                             (char *) conv_str, str_size);
2457 }
2458
2459 static void map_dword_into_ctr(REGVAL_CTR *ctr, const char *val_name,
2460                                uint32 dword)
2461 {
2462         regval_ctr_delvalue(ctr, val_name);
2463         regval_ctr_addvalue(ctr, val_name, REG_DWORD,
2464                             (char *) &dword, sizeof(dword));
2465 }
2466
2467 static void map_bool_into_ctr(REGVAL_CTR *ctr, const char *val_name,
2468                               BOOL bool)
2469 {
2470         uint8 bin_bool = (bool ? 1 : 0);
2471         regval_ctr_delvalue(ctr, val_name);
2472         regval_ctr_addvalue(ctr, val_name, REG_BINARY,
2473                             (char *) &bin_bool, sizeof(bin_bool));
2474 }
2475
2476 static void map_single_multi_sz_into_ctr(REGVAL_CTR *ctr, const char *val_name,
2477                                          const char *multi_sz)
2478 {
2479         smb_ucs2_t *conv_strs = NULL;
2480         size_t str_size;
2481
2482         /* a multi-sz has to have a null string terminator, i.e., the last
2483            string must be followed by two nulls */
2484         str_size = (strlen(multi_sz) + 2) * sizeof(smb_ucs2_t);
2485         conv_strs = calloc(str_size, 1);
2486
2487         push_ucs2(NULL, conv_strs, multi_sz, str_size,
2488                   STR_TERMINATE | STR_NOALIGN);
2489
2490         regval_ctr_delvalue(ctr, val_name);
2491         regval_ctr_addvalue(ctr, val_name, REG_MULTI_SZ,
2492                             (char *) conv_strs, str_size);
2493         safe_free(conv_strs);
2494
2495 }
2496
2497 /****************************************************************************
2498  * Map the NT_PRINTER_INFO_LEVEL_2 data into DsSpooler keys for publishing.
2499  *
2500  * @param info2 NT_PRINTER_INFO_LEVEL_2 describing printer - gets modified
2501  * @return BOOL indicating success or failure
2502  ***************************************************************************/
2503
2504 static BOOL map_nt_printer_info2_to_dsspooler(NT_PRINTER_INFO_LEVEL_2 *info2)
2505 {
2506         REGVAL_CTR *ctr = NULL;
2507         fstring longname;
2508         char *ascii_str;
2509         int i;
2510
2511         if ((i = lookup_printerkey(&info2->data, SPOOL_DSSPOOLER_KEY)) < 0)
2512                 i = add_new_printer_key(&info2->data, SPOOL_DSSPOOLER_KEY);
2513         ctr = &info2->data.keys[i].values;
2514
2515         map_sz_into_ctr(ctr, SPOOL_REG_PRINTERNAME, info2->sharename);
2516         map_sz_into_ctr(ctr, SPOOL_REG_SHORTSERVERNAME, global_myname());
2517
2518         get_myfullname(longname);
2519         map_sz_into_ctr(ctr, SPOOL_REG_SERVERNAME, longname);
2520
2521         asprintf(&ascii_str, "\\\\%s\\%s", longname, info2->sharename);
2522         map_sz_into_ctr(ctr, SPOOL_REG_UNCNAME, ascii_str);
2523         safe_free(ascii_str);
2524
2525
2526         map_dword_into_ctr(ctr, SPOOL_REG_VERSIONNUMBER, 4);
2527         map_sz_into_ctr(ctr, SPOOL_REG_DRIVERNAME, info2->drivername);
2528         map_sz_into_ctr(ctr, SPOOL_REG_LOCATION, info2->location);
2529         map_sz_into_ctr(ctr, SPOOL_REG_DESCRIPTION, info2->comment);
2530         map_single_multi_sz_into_ctr(ctr, SPOOL_REG_PORTNAME, info2->portname);
2531         map_sz_into_ctr(ctr, SPOOL_REG_PRINTSEPARATORFILE, info2->sepfile);
2532         map_dword_into_ctr(ctr, SPOOL_REG_PRINTSTARTTIME, info2->starttime);
2533         map_dword_into_ctr(ctr, SPOOL_REG_PRINTENDTIME, info2->untiltime);
2534         map_dword_into_ctr(ctr, SPOOL_REG_PRIORITY, info2->priority);
2535
2536         map_bool_into_ctr(ctr, SPOOL_REG_PRINTKEEPPRINTEDJOBS,
2537                           (info2->attributes &
2538                            PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS));
2539
2540         switch (info2->attributes & 0x3) {
2541         case 0:
2542                 ascii_str = SPOOL_REGVAL_PRINTWHILESPOOLING;
2543                 break;
2544         case 1:
2545                 ascii_str = SPOOL_REGVAL_PRINTAFTERSPOOLED;
2546                 break;
2547         case 2:
2548                 ascii_str = SPOOL_REGVAL_PRINTDIRECT;
2549                 break;
2550         default:
2551                 ascii_str = "unknown";
2552         }
2553         map_sz_into_ctr(ctr, SPOOL_REG_PRINTSPOOLING, ascii_str);
2554
2555         return True;
2556 }
2557
2558 #ifdef HAVE_ADS
2559 static void store_printer_guid(NT_PRINTER_INFO_LEVEL_2 *info2, GUID guid)
2560 {
2561         int i;
2562         REGVAL_CTR *ctr=NULL;
2563
2564         /* find the DsSpooler key */
2565         if ((i = lookup_printerkey(&info2->data, SPOOL_DSSPOOLER_KEY)) < 0)
2566                 i = add_new_printer_key(&info2->data, SPOOL_DSSPOOLER_KEY);
2567         ctr = &info2->data.keys[i].values;
2568
2569         regval_ctr_delvalue(ctr, "objectGUID");
2570         regval_ctr_addvalue(ctr, "objectGUID", REG_BINARY,
2571                             (char *) &guid, sizeof(GUID));
2572 }
2573
2574 static WERROR publish_it(NT_PRINTER_INFO_LEVEL *printer)
2575 {
2576         ADS_STATUS ads_rc;
2577         TALLOC_CTX *ctx = talloc_init("publish_it");
2578         ADS_MODLIST mods = ads_init_mods(ctx);
2579         char *prt_dn = NULL, *srv_dn, **srv_cn;
2580         void *res = NULL;
2581         ADS_STRUCT *ads;
2582         const char *attrs[] = {"objectGUID", NULL};
2583         GUID guid;
2584         WERROR win_rc = WERR_OK;
2585
2586         ZERO_STRUCT(guid);
2587         /* set the DsSpooler info and attributes */
2588         if (!(map_nt_printer_info2_to_dsspooler(printer->info_2)))
2589                         return WERR_NOMEM;
2590         printer->info_2->attributes |= PRINTER_ATTRIBUTE_PUBLISHED;
2591         win_rc = mod_a_printer(*printer, 2);
2592         if (!W_ERROR_IS_OK(win_rc)) {
2593                 DEBUG(3, ("err %d saving data\n",
2594                                   W_ERROR_V(win_rc)));
2595                 return win_rc;
2596         }
2597
2598         /* Build the ads mods */
2599         get_local_printer_publishing_data(ctx, &mods,
2600                                           &printer->info_2->data);
2601         ads_mod_str(ctx, &mods, SPOOL_REG_PRINTERNAME,
2602                     printer->info_2->sharename);
2603
2604         /* connect to the ADS server */
2605         ads = ads_init(NULL, NULL, lp_ads_server());
2606         if (!ads) {
2607                 DEBUG(3, ("ads_init() failed\n"));
2608                 return WERR_SERVER_UNAVAILABLE;
2609         }
2610         ads_rc = ads_connect(ads);
2611         if (!ADS_ERR_OK(ads_rc)) {
2612                 DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_rc)));
2613                 ads_destroy(&ads);
2614                 return WERR_ACCESS_DENIED;
2615         }
2616
2617         /* figure out where to publish */
2618         ads_find_machine_acct(ads, &res, global_myname());
2619         srv_dn = ldap_get_dn(ads->ld, res);
2620         ads_msgfree(ads, res);
2621         srv_cn = ldap_explode_dn(srv_dn, 1);
2622         asprintf(&prt_dn, "cn=%s-%s,%s", srv_cn[0],
2623                  printer->info_2->sharename, srv_dn);
2624         ads_memfree(ads, srv_dn);
2625
2626         /* publish it */
2627         ads_rc = ads_add_printer_entry(ads, prt_dn, ctx, &mods);
2628         if (LDAP_ALREADY_EXISTS == ads_rc.err.rc)
2629                 ads_rc = ads_mod_printer_entry(ads, prt_dn, ctx,&mods);
2630
2631         /* retreive the guid and store it locally */
2632         if (ADS_ERR_OK(ads_search_dn(ads, &res, prt_dn, attrs))) {
2633                 ads_memfree(ads, prt_dn);
2634                 ads_pull_guid(ads, res, &guid);
2635                 ads_msgfree(ads, res);
2636                 store_printer_guid(printer->info_2, guid);
2637                 win_rc = mod_a_printer(*printer, 2);
2638         }
2639
2640         safe_free(prt_dn);
2641         ads_destroy(&ads);
2642
2643         return WERR_OK;
2644 }
2645
2646 WERROR unpublish_it(NT_PRINTER_INFO_LEVEL *printer)
2647 {
2648         ADS_STATUS ads_rc;
2649         ADS_STRUCT *ads;
2650         void *res;
2651         char *prt_dn = NULL;
2652         WERROR win_rc;
2653
2654         printer->info_2->attributes ^= PRINTER_ATTRIBUTE_PUBLISHED;
2655         win_rc = mod_a_printer(*printer, 2);
2656         if (!W_ERROR_IS_OK(win_rc)) {
2657                 DEBUG(3, ("err %d saving data\n",
2658                                   W_ERROR_V(win_rc)));
2659                 return win_rc;
2660         }
2661
2662         ads = ads_init(NULL, NULL, lp_ads_server());
2663         if (!ads) {
2664                 DEBUG(3, ("ads_init() failed\n"));
2665                 return WERR_SERVER_UNAVAILABLE;
2666         }
2667         ads_rc = ads_connect(ads);
2668         if (!ADS_ERR_OK(ads_rc)) {
2669                 DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_rc)));
2670                 ads_destroy(&ads);
2671                 return WERR_ACCESS_DENIED;
2672         }
2673
2674         /* remove the printer from the directory */
2675         ads_rc = ads_find_printer_on_server(ads, &res,
2676                             printer->info_2->sharename, global_myname());
2677         if (ADS_ERR_OK(ads_rc) && ads_count_replies(ads, res)) {
2678                 prt_dn = ads_get_dn(ads, res);
2679                 ads_msgfree(ads, res);
2680                 ads_rc = ads_del_dn(ads, prt_dn);
2681                 ads_memfree(ads, prt_dn);
2682         }
2683
2684         ads_destroy(&ads);
2685         return WERR_OK;
2686 }
2687
2688 /****************************************************************************
2689  * Publish a printer in the directory
2690  *
2691  * @param snum describing printer service
2692  * @return WERROR indicating status of publishing
2693  ***************************************************************************/
2694
2695 WERROR nt_printer_publish(int snum, int action)
2696 {
2697         NT_PRINTER_INFO_LEVEL *printer = NULL;
2698         WERROR win_rc;
2699
2700         win_rc = get_a_printer(&printer, 2, lp_servicename(snum));
2701         if (!W_ERROR_IS_OK(win_rc))
2702                 return win_rc;
2703
2704         switch(action) {
2705         case SPOOL_DS_PUBLISH:
2706         case SPOOL_DS_UPDATE:
2707                 win_rc = publish_it(printer);
2708                 break;
2709         case SPOOL_DS_UNPUBLISH:
2710                 win_rc = unpublish_it(printer);
2711                 break;
2712         default:
2713                 win_rc = WERR_NOT_SUPPORTED;
2714         }
2715
2716
2717         free_a_printer(&printer, 2);
2718         return win_rc;
2719 }
2720
2721 BOOL is_printer_published(int snum, GUID *guid)
2722 {
2723         NT_PRINTER_INFO_LEVEL *printer = NULL;
2724         REGVAL_CTR *ctr;
2725         REGISTRY_VALUE *guid_val;
2726         WERROR win_rc;
2727         int i;
2728
2729
2730         win_rc = get_a_printer(&printer, 2, lp_servicename(snum));
2731         if (!W_ERROR_IS_OK(win_rc))
2732                 return False;
2733
2734         if (!(printer->info_2->attributes & PRINTER_ATTRIBUTE_PUBLISHED))
2735                 return False;
2736
2737         if ((i = lookup_printerkey(&printer->info_2->data,
2738                                    SPOOL_DSSPOOLER_KEY)) < 0)
2739                 return False;
2740
2741         ctr = &printer->info_2->data.keys[i].values;
2742
2743         guid_val = regval_ctr_getvalue(ctr, "objectGUID");
2744         if (regval_size(guid_val) == sizeof(GUID))
2745                 memcpy(guid, regval_data_p(guid_val), sizeof(GUID));
2746
2747         return True;
2748 }
2749
2750 #else
2751 WERROR nt_printer_publish(int snum, int action)
2752 {
2753         return WERR_OK;
2754 }
2755 BOOL is_printer_published(int snum, GUID *guid)
2756 {
2757         return False;
2758 }
2759 #endif
2760 /****************************************************************************
2761  ***************************************************************************/
2762
2763 WERROR delete_all_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, char *key )
2764 {
2765         NT_PRINTER_DATA *data;
2766         int             i;
2767         int             removed_keys = 0;
2768         int             empty_slot;
2769
2770         data = &p2->data;
2771         empty_slot = data->num_keys;
2772
2773         if ( !key )
2774                 return WERR_INVALID_PARAM;
2775
2776         /* remove all keys */
2777
2778         if ( !strlen(key) )
2779         {
2780                 for ( i=0; i<data->num_keys; i++ )
2781                 {
2782                         DEBUG(8,("delete_all_printer_data: Removed all Printer Data from key [%s]\n",
2783                                 data->keys[i].name));
2784
2785                         SAFE_FREE( data->keys[i].name );
2786                         regval_ctr_destroy( &data->keys[i].values );
2787                 }
2788
2789                 DEBUG(8,("delete_all_printer_data: Removed all Printer Data from printer [%s]\n",
2790                         p2->printername ));
2791
2792                 SAFE_FREE( data->keys );
2793                 ZERO_STRUCTP( data );
2794
2795                 return WERR_OK;
2796         }
2797
2798         /* remove a specific key (and all subkeys) */
2799
2800         for ( i=0; i<data->num_keys; i++ )
2801         {
2802                 if ( StrnCaseCmp( data->keys[i].name, key, strlen(key)) == 0 )
2803                 {
2804                         DEBUG(8,("delete_all_printer_data: Removed all Printer Data from key [%s]\n",
2805                                 data->keys[i].name));
2806
2807                         SAFE_FREE( data->keys[i].name );
2808                         regval_ctr_destroy( &data->keys[i].values );
2809
2810                         /* mark the slot as empty */
2811
2812                         ZERO_STRUCTP( &data->keys[i] );
2813                 }
2814         }
2815
2816         /* find the first empty slot */
2817
2818         for ( i=0; i<data->num_keys; i++ ) {
2819                 if ( !data->keys[i].name ) {
2820                         empty_slot = i;
2821                         removed_keys++;
2822                         break;
2823                 }
2824         }
2825
2826         if ( i == data->num_keys )
2827                 /* nothing was removed */
2828                 return WERR_INVALID_PARAM;
2829
2830         /* move everything down */
2831
2832         for ( i=empty_slot+1; i<data->num_keys; i++ ) {
2833                 if ( data->keys[i].name ) {
2834                         memcpy( &data->keys[empty_slot], &data->keys[i], sizeof(NT_PRINTER_KEY) );
2835                         ZERO_STRUCTP( &data->keys[i] );
2836                         empty_slot++;
2837                         removed_keys++;
2838                 }
2839         }
2840
2841         /* update count */
2842
2843         data->num_keys -= removed_keys;
2844
2845         /* sanity check to see if anything is left */
2846
2847         if ( !data->num_keys )
2848         {
2849                 DEBUG(8,("delete_all_printer_data: No keys left for printer [%s]\n", p2->printername ));
2850
2851                 SAFE_FREE( data->keys );
2852                 ZERO_STRUCTP( data );
2853         }
2854
2855         return WERR_OK;
2856 }
2857
2858 /****************************************************************************
2859  ***************************************************************************/
2860
2861 WERROR delete_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, char *key, char *value )
2862 {
2863         WERROR          result = WERR_OK;
2864         int             key_index;
2865
2866         /* we must have names on non-zero length */
2867
2868         if ( !key || !*key|| !value || !*value )
2869                 return WERR_INVALID_NAME;
2870
2871         /* find the printer key first */
2872
2873         key_index = lookup_printerkey( &p2->data, key );
2874         if ( key_index == -1 )
2875                 return WERR_OK;
2876
2877         regval_ctr_delvalue( &p2->data.keys[key_index].values, value );
2878
2879         DEBUG(8,("delete_printer_data: Removed key => [%s], value => [%s]\n",
2880                 key, value ));
2881
2882         return result;
2883 }
2884
2885 /****************************************************************************
2886  ***************************************************************************/
2887
2888 WERROR add_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, char *key, char *value,
2889                            uint32 type, uint8 *data, int real_len )
2890 {
2891         WERROR          result = WERR_OK;
2892         int             key_index;
2893
2894         /* we must have names on non-zero length */
2895
2896         if ( !key || !*key|| !value || !*value )
2897                 return WERR_INVALID_NAME;
2898
2899         /* find the printer key first */
2900
2901         key_index = lookup_printerkey( &p2->data, key );
2902         if ( key_index == -1 )
2903                 key_index = add_new_printer_key( &p2->data, key );
2904
2905         if ( key_index == -1 )
2906                 return WERR_NOMEM;
2907
2908         regval_ctr_addvalue( &p2->data.keys[key_index].values, value,
2909                 type, data, real_len );
2910
2911         DEBUG(8,("add_printer_data: Added key => [%s], value => [%s], type=> [%d], size => [%d]\n",
2912                 key, value, type, real_len  ));
2913
2914         return result;
2915 }
2916
2917 /****************************************************************************
2918  ***************************************************************************/
2919
2920 REGISTRY_VALUE* get_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, char *key, char *value )
2921 {
2922         int             key_index;
2923
2924         if ( (key_index = lookup_printerkey( &p2->data, key )) == -1 )
2925                 return NULL;
2926
2927         DEBUG(8,("get_printer_data: Attempting to lookup key => [%s], value => [%s]\n",
2928                 key, value ));
2929
2930         return regval_ctr_getvalue( &p2->data.keys[key_index].values, value );
2931 }
2932
2933 /****************************************************************************
2934  Unpack a list of registry values frem the TDB
2935  ***************************************************************************/
2936
2937 static int unpack_values(NT_PRINTER_DATA *printer_data, char *buf, int buflen)
2938 {
2939         int             len = 0;
2940         uint32          type;
2941         pstring         string, valuename, keyname;
2942         char            *str;
2943         int             size;
2944         uint8           *data_p;
2945         REGISTRY_VALUE  *regval_p;
2946         int             key_index;
2947
2948         /* add the "PrinterDriverData" key first for performance reasons */
2949
2950         add_new_printer_key( printer_data, SPOOL_PRINTERDATA_KEY );
2951
2952         /* loop and unpack the rest of the registry values */
2953
2954         while ( True )
2955         {
2956
2957                 /* check to see if there are any more registry values */
2958
2959                 len += tdb_unpack(buf+len, buflen-len, "p", &regval_p);
2960                 if ( !regval_p )
2961                         break;
2962
2963                 /* unpack the next regval */
2964
2965                 len += tdb_unpack(buf+len, buflen-len, "fdB",
2966                                   string,
2967                                   &type,
2968                                   &size,
2969                                   &data_p);
2970
2971                 /*
2972                  * break of the keyname from the value name.
2973                  * Should only be one '\' in the string returned.
2974                  */
2975
2976                 str = strrchr( string, '\\');
2977
2978                 /* Put in "PrinterDriverData" is no key specified */
2979
2980                 if ( !str ) {
2981                         pstrcpy( keyname, SPOOL_PRINTERDATA_KEY );
2982                         pstrcpy( valuename, string );
2983                 }
2984                 else {
2985                         *str = '\0';
2986                         pstrcpy( keyname, string );
2987                         pstrcpy( valuename, str+1 );
2988                 }
2989
2990                 /* see if we need a new key */
2991
2992                 if ( (key_index=lookup_printerkey( printer_data, keyname )) == -1 )
2993                         key_index = add_new_printer_key( printer_data, keyname );
2994
2995                 if ( key_index == -1 ) {
2996                         DEBUG(0,("unpack_values: Failed to allocate a new key [%s]!\n",
2997                                 keyname));
2998                         break;
2999                 }
3000
3001                 /* add the new value */
3002
3003                 regval_ctr_addvalue( &printer_data->keys[key_index].values, valuename, type, data_p, size );
3004
3005                 SAFE_FREE(data_p); /* 'B' option to tdb_unpack does a malloc() */
3006                 DEBUG(8,("specific: [%s:%s], len: %d\n", keyname, valuename, size));
3007         }
3008
3009         return len;
3010 }
3011
3012 /****************************************************************************
3013  ***************************************************************************/
3014
3015 static void map_to_os2_driver(fstring drivername)
3016 {
3017         static BOOL initialised=False;
3018         static fstring last_from,last_to;
3019         char *mapfile = lp_os2_driver_map();
3020         char **lines = NULL;
3021         int numlines = 0;
3022         int i;
3023
3024         if (!strlen(drivername))
3025                 return;
3026
3027         if (!*mapfile)
3028                 return;
3029
3030         if (!initialised) {
3031                 *last_from = *last_to = 0;
3032                 initialised = True;
3033         }
3034
3035         if (strequal(drivername,last_from)) {
3036                 DEBUG(3,("Mapped Windows driver %s to OS/2 driver %s\n",drivername,last_to));
3037                 fstrcpy(drivername,last_to);
3038                 return;
3039         }
3040
3041         lines = file_lines_load(mapfile, &numlines);
3042         if (numlines == 0) {
3043                 DEBUG(0,("No entries in OS/2 driver map %s\n",mapfile));
3044                 return;
3045         }
3046
3047         DEBUG(4,("Scanning OS/2 driver map %s\n",mapfile));
3048
3049         for( i = 0; i < numlines; i++) {
3050                 char *nt_name = lines[i];
3051                 char *os2_name = strchr(nt_name,'=');
3052
3053                 if (!os2_name)
3054                         continue;
3055
3056                 *os2_name++ = 0;
3057
3058                 while (isspace(*nt_name))
3059                         nt_name++;
3060
3061                 if (!*nt_name || strchr("#;",*nt_name))
3062                         continue;
3063
3064                 {
3065                         int l = strlen(nt_name);
3066                         while (l && isspace(nt_name[l-1])) {
3067                                 nt_name[l-1] = 0;
3068                                 l--;
3069                         }
3070                 }
3071
3072                 while (isspace(*os2_name))
3073                         os2_name++;
3074
3075                 {
3076                         int l = strlen(os2_name);
3077                         while (l && isspace(os2_name[l-1])) {
3078                                 os2_name[l-1] = 0;
3079                                 l--;
3080                         }
3081                 }
3082
3083                 if (strequal(nt_name,drivername)) {
3084                         DEBUG(3,("Mapped windows driver %s to os2 driver%s\n",drivername,os2_name));
3085                         fstrcpy(last_from,drivername);
3086                         fstrcpy(last_to,os2_name);
3087                         fstrcpy(drivername,os2_name);
3088                         file_lines_free(lines);
3089                         return;
3090                 }
3091         }
3092
3093         file_lines_free(lines);
3094 }
3095
3096 /****************************************************************************
3097 get a default printer info 2 struct
3098 ****************************************************************************/
3099 static WERROR get_a_printer_2_default(NT_PRINTER_INFO_LEVEL_2 **info_ptr, fstring sharename)
3100 {
3101         int snum;
3102         NT_PRINTER_INFO_LEVEL_2 info;
3103
3104         ZERO_STRUCT(info);
3105
3106         snum = lp_servicenumber(sharename);
3107
3108         slprintf(info.servername, sizeof(info.servername)-1, "\\\\%s", get_called_name());
3109         slprintf(info.printername, sizeof(info.printername)-1, "\\\\%s\\%s",
3110                  get_called_name(), sharename);
3111         fstrcpy(info.sharename, sharename);
3112         fstrcpy(info.portname, SAMBA_PRINTER_PORT_NAME);
3113
3114         /* by setting the driver name to an empty string, a local NT admin
3115            can now run the **local** APW to install a local printer driver
3116            for a Samba shared printer in 2.2.  Without this, drivers **must** be
3117            installed on the Samba server for NT clients --jerry */
3118 #if 0   /* JERRY --do not uncomment-- */
3119         if (!*info.drivername)
3120                 fstrcpy(info.drivername, "NO DRIVER AVAILABLE FOR THIS PRINTER");
3121 #endif
3122
3123
3124         DEBUG(10,("get_a_printer_2_default: driver name set to [%s]\n", info.drivername));
3125
3126         pstrcpy(info.comment, "");
3127         fstrcpy(info.printprocessor, "winprint");
3128         fstrcpy(info.datatype, "RAW");
3129
3130         info.attributes = PRINTER_ATTRIBUTE_SHARED | PRINTER_ATTRIBUTE_NETWORK;      /* attributes */
3131
3132         info.starttime = 0; /* Minutes since 12:00am GMT */
3133         info.untiltime = 0; /* Minutes since 12:00am GMT */
3134         info.priority = 1;
3135         info.default_priority = 1;
3136         info.setuptime = (uint32)time(NULL);
3137
3138         /*
3139          * I changed this as I think it is better to have a generic
3140          * DEVMODE than to crash Win2k explorer.exe   --jerry
3141          * See the HP Deskjet 990c Win2k drivers for an example.
3142          *
3143          * However the default devmode appears to cause problems
3144          * with the HP CLJ 8500 PCL driver.  Hence the addition of
3145          * the "default devmode" parameter   --jerry 22/01/2002
3146          */
3147
3148         if (lp_default_devmode(snum)) {
3149                 if ((info.devmode = construct_nt_devicemode(info.printername)) == NULL)
3150                         goto fail;
3151         }
3152         else {
3153                 info.devmode = NULL;
3154         }
3155
3156         /* This will get the current RPC talloc context, but we should be
3157            passing this as a parameter... fixme... JRA ! */
3158
3159         if (!nt_printing_getsec(get_talloc_ctx(), sharename, &info.secdesc_buf))
3160                 goto fail;
3161
3162         *info_ptr = (NT_PRINTER_INFO_LEVEL_2 *)memdup(&info, sizeof(info));
3163         if (! *info_ptr) {
3164                 DEBUG(0,("get_a_printer_2_default: malloc fail.\n"));
3165                 goto fail;
3166         }
3167
3168         return WERR_OK;
3169
3170   fail:
3171         if (info.devmode)
3172                 free_nt_devicemode(&info.devmode);
3173         return WERR_ACCESS_DENIED;
3174 }
3175
3176 /****************************************************************************
3177 ****************************************************************************/
3178 static WERROR get_a_printer_2(NT_PRINTER_INFO_LEVEL_2 **info_ptr, fstring sharename)
3179 {
3180         pstring key;
3181         NT_PRINTER_INFO_LEVEL_2 info;
3182         int             len = 0;
3183         TDB_DATA kbuf, dbuf;
3184         fstring printername;
3185
3186         ZERO_STRUCT(info);
3187
3188         slprintf(key, sizeof(key)-1, "%s%s", PRINTERS_PREFIX, sharename);
3189
3190         kbuf.dptr = key;
3191         kbuf.dsize = strlen(key)+1;
3192
3193         dbuf = tdb_fetch(tdb_printers, kbuf);
3194         if (!dbuf.dptr)
3195                 return get_a_printer_2_default(info_ptr, sharename);
3196
3197         len += tdb_unpack(dbuf.dptr+len, dbuf.dsize-len, "dddddddddddfffffPfffff",
3198                         &info.attributes,
3199                         &info.priority,
3200                         &info.default_priority,
3201                         &info.starttime,
3202                         &info.untiltime,
3203                         &info.status,
3204                         &info.cjobs,
3205                         &info.averageppm,
3206                         &info.changeid,
3207                         &info.c_setprinter,
3208                         &info.setuptime,
3209                         info.servername,
3210                         info.printername,
3211                         info.sharename,
3212                         info.portname,
3213                         info.drivername,
3214                         info.comment,
3215                         info.location,
3216                         info.sepfile,
3217                         info.printprocessor,
3218                         info.datatype,
3219                         info.parameters);
3220
3221         /* Samba has to have shared raw drivers. */
3222         info.attributes |= (PRINTER_ATTRIBUTE_SHARED | PRINTER_ATTRIBUTE_NETWORK);
3223
3224         /* Restore the stripped strings. */
3225         slprintf(info.servername, sizeof(info.servername)-1, "\\\\%s", get_called_name());
3226         slprintf(printername, sizeof(printername)-1, "\\\\%s\\%s", get_called_name(),
3227                         info.printername);
3228         fstrcpy(info.printername, printername);
3229
3230         len += unpack_devicemode(&info.devmode,dbuf.dptr+len, dbuf.dsize-len);
3231
3232         /*
3233          * Some client drivers freak out if there is a NULL devmode
3234          * (probably the driver is not checking before accessing
3235          * the devmode pointer)   --jerry
3236          *
3237          * See comments in get_a_printer_2_default()
3238          */
3239
3240         if (lp_default_devmode(lp_servicenumber(sharename)) && !info.devmode) {
3241                 DEBUG(8,("get_a_printer_2: Constructing a default device mode for [%s]\n",
3242                         printername));
3243                 info.devmode = construct_nt_devicemode(printername);
3244         }
3245
3246         len += unpack_values( &info.data, dbuf.dptr+len, dbuf.dsize-len );
3247
3248         /* This will get the current RPC talloc context, but we should be
3249            passing this as a parameter... fixme... JRA ! */
3250
3251         nt_printing_getsec(get_talloc_ctx(), sharename, &info.secdesc_buf);
3252
3253         /* Fix for OS/2 drivers. */
3254
3255         if (get_remote_arch() == RA_OS2)
3256                 map_to_os2_driver(info.drivername);
3257
3258         SAFE_FREE(dbuf.dptr);
3259         *info_ptr=memdup(&info, sizeof(info));
3260
3261         DEBUG(9,("Unpacked printer [%s] name [%s] running driver [%s]\n",
3262                  sharename, info.printername, info.drivername));
3263
3264         return WERR_OK;
3265 }
3266
3267 /****************************************************************************
3268 debugging function, dump at level 6 the struct in the logs
3269 ****************************************************************************/
3270 static uint32 dump_a_printer(NT_PRINTER_INFO_LEVEL printer, uint32 level)
3271 {
3272         uint32 result;
3273         NT_PRINTER_INFO_LEVEL_2 *info2;
3274
3275         DEBUG(106,("Dumping printer at level [%d]\n", level));
3276
3277         switch (level)
3278         {
3279                 case 2:
3280                 {
3281                         if (printer.info_2 == NULL)
3282                                 result=5;
3283                         else
3284                         {
3285                                 info2=printer.info_2;
3286
3287                                 DEBUGADD(106,("attributes:[%d]\n", info2->attributes));
3288                                 DEBUGADD(106,("priority:[%d]\n", info2->priority));
3289                                 DEBUGADD(106,("default_priority:[%d]\n", info2->default_priority));
3290                                 DEBUGADD(106,("starttime:[%d]\n", info2->starttime));
3291                                 DEBUGADD(106,("untiltime:[%d]\n", info2->untiltime));
3292                                 DEBUGADD(106,("status:[%d]\n", info2->status));
3293                                 DEBUGADD(106,("cjobs:[%d]\n", info2->cjobs));
3294                                 DEBUGADD(106,("averageppm:[%d]\n", info2->averageppm));
3295                                 DEBUGADD(106,("changeid:[%d]\n", info2->changeid));
3296                                 DEBUGADD(106,("c_setprinter:[%d]\n", info2->c_setprinter));
3297                                 DEBUGADD(106,("setuptime:[%d]\n", info2->setuptime));
3298
3299                                 DEBUGADD(106,("servername:[%s]\n", info2->servername));
3300                                 DEBUGADD(106,("printername:[%s]\n", info2->printername));
3301                                 DEBUGADD(106,("sharename:[%s]\n", info2->sharename));
3302                                 DEBUGADD(106,("portname:[%s]\n", info2->portname));
3303                                 DEBUGADD(106,("drivername:[%s]\n", info2->drivername));
3304                                 DEBUGADD(106,("comment:[%s]\n", info2->comment));
3305                                 DEBUGADD(106,("location:[%s]\n", info2->location));
3306                                 DEBUGADD(106,("sepfile:[%s]\n", info2->sepfile));
3307                                 DEBUGADD(106,("printprocessor:[%s]\n", info2->printprocessor));
3308                                 DEBUGADD(106,("datatype:[%s]\n", info2->datatype));
3309                                 DEBUGADD(106,("parameters:[%s]\n", info2->parameters));
3310                                 result=0;
3311                         }
3312                         break;
3313                 }
3314                 default:
3315                         DEBUGADD(106,("dump_a_printer: Level %u not implemented\n", (unsigned int)level ));
3316                         result=1;
3317                         break;
3318         }
3319
3320         return result;
3321 }
3322
3323 /****************************************************************************
3324  Get the parameters we can substitute in an NT print job.
3325 ****************************************************************************/
3326
3327 void get_printer_subst_params(int snum, fstring *printername, fstring *sharename, fstring *portname)
3328 {
3329         NT_PRINTER_INFO_LEVEL *printer = NULL;
3330
3331         **printername = **sharename = **portname = '\0';
3332
3333         if (!W_ERROR_IS_OK(get_a_printer(&printer, 2, lp_servicename(snum))))
3334                 return;
3335
3336         fstrcpy(*printername, printer->info_2->printername);
3337         fstrcpy(*sharename, printer->info_2->sharename);
3338         fstrcpy(*portname, printer->info_2->portname);
3339
3340         free_a_printer(&printer, 2);
3341 }
3342
3343 /****************************************************************************
3344  Update the changeid time.
3345  This is SO NASTY as some drivers need this to change, others need it
3346  static. This value will change every second, and I must hope that this
3347  is enough..... DON'T CHANGE THIS CODE WITHOUT A TEST MATRIX THE SIZE OF
3348  UTAH ! JRA.
3349 ****************************************************************************/
3350
3351 static uint32 rev_changeid(void)
3352 {
3353         struct timeval tv;
3354
3355         get_process_uptime(&tv);
3356
3357 #if 1   /* JERRY */
3358         /* Return changeid as msec since spooler restart */
3359         return tv.tv_sec * 1000 + tv.tv_usec / 1000;
3360 #else
3361         /*
3362          * This setting seems to work well but is too untested
3363          * to replace the above calculation.  Left in for experiementation
3364          * of the reader            --jerry (Tue Mar 12 09:15:05 CST 2002)
3365          */
3366         return tv.tv_sec * 10 + tv.tv_usec / 100000;
3367 #endif
3368 }
3369
3370 /*
3371  * The function below are the high level ones.
3372  * only those ones must be called from the spoolss code.
3373  * JFM.
3374  */
3375
3376 /****************************************************************************
3377  Modify a printer. This is called from SETPRINTERDATA/DELETEPRINTERDATA.
3378 ****************************************************************************/
3379
3380 WERROR mod_a_printer(NT_PRINTER_INFO_LEVEL printer, uint32 level)
3381 {
3382         WERROR result;
3383
3384         dump_a_printer(printer, level);
3385
3386         switch (level)
3387         {
3388                 case 2:
3389                 {
3390                         /*
3391                          * Update the changestamp.  Emperical tests show that the
3392                          * ChangeID is always updated,but c_setprinter is
3393                          *  global spooler variable (not per printer).
3394                          */
3395
3396                         /* ChangeID **must** be increasing over the lifetime
3397                            of client's spoolss service in order for the
3398                            client's cache to show updates */
3399
3400                         printer.info_2->changeid = rev_changeid();
3401
3402                         /*
3403                          * Because one day someone will ask:
3404                          * NT->NT       An admin connection to a remote
3405                          *              printer show changes imeediately in
3406                          *              the properities dialog
3407                          *
3408                          *              A non-admin connection will only show the
3409                          *              changes after viewing the properites page
3410                          *              2 times.  Seems to be related to a
3411                          *              race condition in the client between the spooler
3412                          *              updating the local cache and the Explorer.exe GUI
3413                          *              actually displaying the properties.
3414                          *
3415                          *              This is fixed in Win2k.  admin/non-admin
3416                          *              connections both display changes immediately.
3417                          *
3418                          * 14/12/01     --jerry
3419                          */
3420
3421                         result=update_a_printer_2(printer.info_2);
3422                         break;
3423                 }
3424                 default:
3425                         result=WERR_UNKNOWN_LEVEL;
3426                         break;
3427         }
3428
3429         return result;
3430 }
3431
3432 /****************************************************************************
3433  Initialize printer devmode & data with previously saved driver init values.
3434 ****************************************************************************/
3435
3436 static BOOL set_driver_init_2( NT_PRINTER_INFO_LEVEL_2 *info_ptr )
3437 {
3438         int                     len = 0;
3439         pstring                 key;
3440         TDB_DATA                kbuf, dbuf;
3441         NT_PRINTER_INFO_LEVEL_2 info;
3442
3443
3444         ZERO_STRUCT(info);
3445
3446         /*
3447          * Delete any printer data 'values' already set. When called for driver
3448          * replace, there will generally be some, but during an add printer, there
3449          * should not be any (if there are delete them).
3450          */
3451
3452         delete_all_printer_data( info_ptr, "" );
3453
3454         slprintf(key, sizeof(key)-1, "%s%s", DRIVER_INIT_PREFIX, info_ptr->drivername);
3455
3456         kbuf.dptr = key;
3457         kbuf.dsize = strlen(key)+1;
3458
3459         dbuf = tdb_fetch(tdb_drivers, kbuf);
3460         if (!dbuf.dptr) {
3461                 /*
3462                  * When changing to a driver that has no init info in the tdb, remove
3463                  * the previous drivers init info and leave the new on blank.
3464                  */
3465                 free_nt_devicemode(&info_ptr->devmode);
3466                 return False;
3467         }
3468
3469         /*
3470          * Get the saved DEVMODE..
3471          */
3472
3473         len += unpack_devicemode(&info.devmode,dbuf.dptr+len, dbuf.dsize-len);
3474
3475         /*
3476          * The saved DEVMODE contains the devicename from the printer used during
3477          * the initialization save. Change it to reflect the new printer.
3478          */
3479
3480         if ( info.devmode ) {
3481                 ZERO_STRUCT(info.devmode->devicename);
3482                 fstrcpy(info.devmode->devicename, info_ptr->printername);
3483         }
3484
3485         /*
3486          * NT/2k does not change out the entire DeviceMode of a printer
3487          * when changing the driver.  Only the driverextra, private, &
3488          * driverversion fields.   --jerry  (Thu Mar 14 08:58:43 CST 2002)
3489          *
3490          * Later examination revealed that Windows NT/2k does reset the
3491          * the printer's device mode, bit **only** when you change a
3492          * property of the device mode such as the page orientation.
3493          * --jerry
3494          */
3495
3496
3497         /* Bind the saved DEVMODE to the new the printer */
3498
3499         free_nt_devicemode(&info_ptr->devmode);
3500         info_ptr->devmode = info.devmode;
3501
3502         DEBUG(10,("set_driver_init_2: Set printer [%s] init %s DEVMODE for driver [%s]\n",
3503                 info_ptr->printername, info_ptr->devmode?"VALID":"NULL", info_ptr->drivername));
3504
3505         /* Add the printer data 'values' to the new printer */
3506
3507         len += unpack_values( &info_ptr->data, dbuf.dptr+len, dbuf.dsize-len );
3508
3509
3510         SAFE_FREE(dbuf.dptr);
3511
3512         return True;
3513 }
3514
3515 /****************************************************************************
3516  Initialize printer devmode & data with previously saved driver init values.
3517  When a printer is created using AddPrinter, the drivername bound to the
3518  printer is used to lookup previously saved driver initialization info, which
3519  is bound to the new printer.
3520 ****************************************************************************/
3521
3522 BOOL set_driver_init(NT_PRINTER_INFO_LEVEL *printer, uint32 level)
3523 {
3524         BOOL result = False;
3525
3526         switch (level)
3527         {
3528                 case 2:
3529                         result = set_driver_init_2(printer->info_2);
3530                         break;
3531
3532                 default:
3533                         DEBUG(0,("set_driver_init: Programmer's error!  Unknown driver_init level [%d]\n",
3534                                 level));
3535                         break;
3536         }
3537
3538         return result;
3539 }
3540
3541 /****************************************************************************
3542  Delete driver init data stored for a specified driver
3543 ****************************************************************************/
3544
3545 BOOL del_driver_init(char *drivername)
3546 {
3547         pstring key;
3548         TDB_DATA kbuf;
3549
3550         if (!drivername || !*drivername) {
3551                 DEBUG(3,("del_driver_init: No drivername specified!\n"));
3552                 return False;
3553         }
3554
3555         slprintf(key, sizeof(key)-1, "%s%s", DRIVER_INIT_PREFIX, drivername);
3556
3557         kbuf.dptr = key;
3558         kbuf.dsize = strlen(key)+1;
3559
3560         DEBUG(6,("del_driver_init: Removing driver init data for [%s]\n", drivername));
3561
3562         return (tdb_delete(tdb_drivers, kbuf) == 0);
3563 }
3564
3565 /****************************************************************************
3566  Pack up the DEVMODE and values for a printer into a 'driver init' entry
3567  in the tdb. Note: this is different from the driver entry and the printer
3568  entry. There should be a single driver init entry for each driver regardless
3569  of whether it was installed from NT or 2K. Technically, they should be
3570  different, but they work out to the same struct.
3571 ****************************************************************************/
3572
3573 static uint32 update_driver_init_2(NT_PRINTER_INFO_LEVEL_2 *info)
3574 {
3575         pstring key;
3576         char *buf;
3577         int buflen, len, ret;
3578         TDB_DATA kbuf, dbuf;
3579
3580         buf = NULL;
3581         buflen = 0;
3582
3583  again:
3584         len = 0;
3585         len += pack_devicemode(info->devmode, buf+len, buflen-len);
3586
3587         len += pack_values( &info->data, buf+len, buflen-len );
3588
3589         if (buflen != len) {
3590                 char *tb;
3591
3592                 tb = (char *)Realloc(buf, len);
3593                 if (!tb) {
3594                         DEBUG(0, ("update_driver_init_2: failed to enlarge buffer!\n"));
3595                         ret = -1;
3596                         goto done;
3597                 }
3598                 else buf = tb;
3599                 buflen = len;
3600                 goto again;
3601         }
3602
3603         slprintf(key, sizeof(key)-1, "%s%s", DRIVER_INIT_PREFIX, info->drivername);
3604
3605         kbuf.dptr = key;
3606         kbuf.dsize = strlen(key)+1;
3607         dbuf.dptr = buf;
3608         dbuf.dsize = len;
3609
3610         ret = tdb_store(tdb_drivers, kbuf, dbuf, TDB_REPLACE);
3611
3612 done:
3613         if (ret == -1)
3614                 DEBUG(8, ("update_driver_init_2: error updating printer init to tdb on disk\n"));
3615
3616         SAFE_FREE(buf);
3617
3618         DEBUG(10,("update_driver_init_2: Saved printer [%s] init DEVMODE & values for driver [%s]\n",
3619                  info->sharename, info->drivername));
3620
3621         return ret;
3622 }
3623
3624 /****************************************************************************
3625  Update (i.e. save) the driver init info (DEVMODE and values) for a printer
3626 ****************************************************************************/
3627
3628 uint32 update_driver_init(NT_PRINTER_INFO_LEVEL printer, uint32 level)
3629 {
3630         uint32 result;
3631
3632         dump_a_printer(printer, level);
3633
3634         switch (level)
3635         {
3636                 case 2:
3637                 {
3638                         result = update_driver_init_2(printer.info_2);
3639                         break;
3640                 }
3641                 default:
3642                         result = 1;
3643                         break;
3644         }
3645
3646         return result;
3647 }
3648
3649 /****************************************************************************
3650  Convert the printer data value, a REG_BINARY array, into an initialization
3651  DEVMODE. Note: the array must be parsed as if it was a DEVMODE in an rpc...
3652  got to keep the endians happy :).
3653 ****************************************************************************/
3654
3655 static BOOL convert_driver_init( TALLOC_CTX *ctx, NT_DEVICEMODE *nt_devmode, uint8 *data, uint32 data_len )
3656 {
3657         BOOL       result = False;
3658         prs_struct ps;
3659         DEVICEMODE devmode;
3660
3661         ZERO_STRUCT(devmode);
3662
3663         prs_init(&ps, 0, ctx, UNMARSHALL);
3664         ps.data_p      = (char *)data;
3665         ps.buffer_size = data_len;
3666
3667         if (spoolss_io_devmode("phantom DEVMODE", &ps, 0, &devmode))
3668                 result = convert_devicemode("", &devmode, &nt_devmode);
3669         else
3670                 DEBUG(10,("convert_driver_init: error parsing DEVMODE\n"));
3671
3672         return result;
3673 }
3674
3675 /****************************************************************************
3676  Set the DRIVER_INIT info in the tdb. Requires Win32 client code that:
3677
3678  1. Use the driver's config DLL to this UNC printername and:
3679     a. Call DrvPrintEvent with PRINTER_EVENT_INITIALIZE
3680     b. Call DrvConvertDevMode with CDM_DRIVER_DEFAULT to get default DEVMODE
3681  2. Call SetPrinterData with the 'magic' key and the DEVMODE as data.
3682
3683  The last step triggers saving the "driver initialization" information for
3684  this printer into the tdb. Later, new printers that use this driver will
3685  have this initialization information bound to them. This simulates the
3686  driver initialization, as if it had run on the Samba server (as it would
3687  have done on NT).
3688
3689  The Win32 client side code requirement sucks! But until we can run arbitrary
3690  Win32 printer driver code on any Unix that Samba runs on, we are stuck with it.
3691
3692  It would have been easier to use SetPrinter because all the UNMARSHALLING of
3693  the DEVMODE is done there, but 2K/XP clients do not set the DEVMODE... think
3694  about it and you will realize why.  JRR 010720
3695 ****************************************************************************/
3696
3697 static WERROR save_driver_init_2(NT_PRINTER_INFO_LEVEL *printer, uint8 *data, uint32 data_len )
3698 {
3699         WERROR        status       = WERR_OK;
3700         TALLOC_CTX    *ctx         = NULL;
3701         NT_DEVICEMODE *nt_devmode  = NULL;
3702         NT_DEVICEMODE *tmp_devmode = printer->info_2->devmode;
3703
3704         /*
3705          * When the DEVMODE is already set on the printer, don't try to unpack it.
3706          */
3707         DEBUG(8,("save_driver_init_2: Enter...\n"));
3708
3709         if ( !printer->info_2->devmode && data_len )
3710         {
3711                 /*
3712                  * Set devmode on printer info, so entire printer initialization can be
3713                  * saved to tdb.
3714                  */
3715
3716                 if ((ctx = talloc_init("save_driver_init_2")) == NULL)
3717                         return WERR_NOMEM;
3718
3719                 if ((nt_devmode = (NT_DEVICEMODE*)malloc(sizeof(NT_DEVICEMODE))) == NULL) {
3720                         status = WERR_NOMEM;
3721                         goto done;
3722                 }
3723
3724                 ZERO_STRUCTP(nt_devmode);
3725
3726                 /*
3727                  * The DEVMODE is held in the 'data' component of the param in raw binary.
3728                  * Convert it to to a devmode structure
3729                  */
3730                 if ( !convert_driver_init( ctx, nt_devmode, data, data_len )) {
3731                         DEBUG(10,("save_driver_init_2: error converting DEVMODE\n"));
3732                         status = WERR_INVALID_PARAM;
3733                         goto done;
3734                 }
3735
3736                 printer->info_2->devmode = nt_devmode;
3737         }
3738
3739         /*
3740          * Pack up and add (or update) the DEVMODE and any current printer data to
3741          * a 'driver init' element in the tdb
3742          *
3743          */
3744
3745         if ( update_driver_init(*printer, 2) != 0 ) {
3746                 DEBUG(10,("save_driver_init_2: error updating DEVMODE\n"));
3747                 status = WERR_NOMEM;
3748                 goto done;
3749         }
3750
3751         /*
3752          * If driver initialization info was successfully saved, set the current
3753          * printer to match it. This allows initialization of the current printer
3754          * as well as the driver.
3755          */
3756         status = mod_a_printer(*printer, 2);
3757         if (!W_ERROR_IS_OK(status)) {
3758                 DEBUG(10,("save_driver_init_2: error setting DEVMODE on printer [%s]\n",
3759                                   printer->info_2->printername));
3760         }
3761
3762   done:
3763         talloc_destroy(ctx);
3764         free_nt_devicemode( &nt_devmode );
3765
3766         printer->info_2->devmode = tmp_devmode;
3767
3768         return status;
3769 }
3770
3771 /****************************************************************************
3772  Update the driver init info (DEVMODE and specifics) for a printer
3773 ****************************************************************************/
3774
3775 WERROR save_driver_init(NT_PRINTER_INFO_LEVEL *printer, uint32 level, uint8 *data, uint32 data_len)
3776 {
3777         WERROR status = WERR_OK;
3778
3779         switch (level)
3780         {
3781                 case 2:
3782                 {
3783                         status = save_driver_init_2( printer, data, data_len );
3784                         break;
3785                 }
3786                 default:
3787                         status = WERR_UNKNOWN_LEVEL;
3788                         break;
3789         }
3790
3791         return status;
3792 }
3793
3794 /****************************************************************************
3795  Get a NT_PRINTER_INFO_LEVEL struct. It returns malloced memory.
3796 ****************************************************************************/
3797
3798 WERROR get_a_printer(NT_PRINTER_INFO_LEVEL **pp_printer, uint32 level, fstring sharename)
3799 {
3800         WERROR result;
3801         NT_PRINTER_INFO_LEVEL *printer = NULL;
3802
3803         *pp_printer = NULL;
3804
3805         DEBUG(10,("get_a_printer: [%s] level %u\n", sharename, (unsigned int)level));
3806
3807         switch (level)
3808         {
3809                 case 2:
3810                 {
3811                         if ((printer = (NT_PRINTER_INFO_LEVEL *)malloc(sizeof(NT_PRINTER_INFO_LEVEL))) == NULL) {
3812                                 DEBUG(0,("get_a_printer: malloc fail.\n"));
3813                                 return WERR_NOMEM;
3814                         }
3815                         ZERO_STRUCTP(printer);
3816                         result=get_a_printer_2(&printer->info_2, sharename);
3817                         if (W_ERROR_IS_OK(result)) {
3818                                 dump_a_printer(*printer, level);
3819                                 *pp_printer = printer;
3820                         } else {
3821                                 SAFE_FREE(printer);
3822                         }
3823                         break;
3824                 }
3825                 default:
3826                         result=WERR_UNKNOWN_LEVEL;
3827                         break;
3828         }
3829
3830         DEBUG(10,("get_a_printer: [%s] level %u returning %s\n", sharename, (unsigned int)level, dos_errstr(result)));
3831
3832         return result;
3833 }
3834
3835 /****************************************************************************
3836  Deletes a NT_PRINTER_INFO_LEVEL struct.
3837 ****************************************************************************/
3838
3839 uint32 free_a_printer(NT_PRINTER_INFO_LEVEL **pp_printer, uint32 level)
3840 {
3841         uint32 result;
3842         NT_PRINTER_INFO_LEVEL *printer = *pp_printer;
3843
3844         DEBUG(104,("freeing a printer at level [%d]\n", level));
3845
3846         if (printer == NULL)
3847                 return 0;
3848
3849         switch (level)
3850         {
3851                 case 2:
3852                 {
3853                         if (printer->info_2 != NULL)
3854                         {
3855                                 free_nt_printer_info_level_2(&printer->info_2);
3856                                 result=0;
3857                         }
3858                         else
3859                         {
3860                                 result=4;
3861                         }
3862                         break;
3863                 }
3864                 default:
3865                         result=1;
3866                         break;
3867         }
3868
3869         SAFE_FREE(*pp_printer);
3870         return result;
3871 }
3872
3873 /****************************************************************************
3874 ****************************************************************************/
3875 uint32 add_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
3876 {
3877         uint32 result;
3878         DEBUG(104,("adding a printer at level [%d]\n", level));
3879         dump_a_printer_driver(driver, level);
3880
3881         switch (level)
3882         {
3883                 case 3:
3884                 {
3885                         result=add_a_printer_driver_3(driver.info_3);
3886                         break;
3887                 }
3888
3889                 case 6:
3890                 {
3891                         result=add_a_printer_driver_6(driver.info_6);
3892                         break;
3893                 }
3894                 default:
3895                         result=1;
3896                         break;
3897         }
3898
3899         return result;
3900 }
3901 /****************************************************************************
3902 ****************************************************************************/
3903 WERROR get_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL *driver, uint32 level,
3904                             fstring drivername, fstring architecture, uint32 version)
3905 {
3906         WERROR result;
3907
3908         switch (level)
3909         {
3910                 case 3:
3911                         /* Sometime we just want any version of the driver */
3912
3913                         if ( version == DRIVER_ANY_VERSION ) {
3914                                 /* look for Win2k first and then for NT4 */
3915                                 result = get_a_printer_driver_3(&driver->info_3, drivername,
3916                                                 architecture, 3);
3917
3918                                 if ( !W_ERROR_IS_OK(result) ) {
3919                                         result = get_a_printer_driver_3( &driver->info_3,
3920                                                         drivername, architecture, 2 );
3921                                 }
3922                         }
3923                         else {
3924                                 result = get_a_printer_driver_3(&driver->info_3, drivername,
3925                                         architecture, version);
3926                         }
3927                         break;
3928
3929                 default:
3930                         result=W_ERROR(1);
3931                         break;
3932         }
3933
3934         if (W_ERROR_IS_OK(result))
3935                 dump_a_printer_driver(*driver, level);
3936
3937         return result;
3938 }
3939
3940 /****************************************************************************
3941 ****************************************************************************/
3942 uint32 free_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
3943 {
3944         uint32 result;
3945
3946         switch (level)
3947         {
3948                 case 3:
3949                 {
3950                         NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3;
3951                         if (driver.info_3 != NULL)
3952                         {
3953                                 info3=driver.info_3;
3954                                 SAFE_FREE(info3->dependentfiles);
3955                                 ZERO_STRUCTP(info3);
3956                                 SAFE_FREE(info3);
3957                                 result=0;
3958                         }
3959                         else
3960                         {
3961                                 result=4;
3962                         }
3963                         break;
3964                 }
3965                 case 6:
3966                 {
3967                         NT_PRINTER_DRIVER_INFO_LEVEL_6 *info6;
3968                         if (driver.info_6 != NULL)
3969                         {
3970                                 info6=driver.info_6;
3971                                 SAFE_FREE(info6->dependentfiles);
3972                                 SAFE_FREE(info6->previousnames);
3973                                 ZERO_STRUCTP(info6);
3974                                 SAFE_FREE(info6);
3975                                 result=0;
3976                         }
3977                         else
3978                         {
3979                                 result=4;
3980                         }
3981                         break;
3982                 }
3983                 default:
3984                         result=1;
3985                         break;
3986         }
3987         return result;
3988 }
3989
3990
3991 /****************************************************************************
3992   Determine whether or not a particular driver is currently assigned
3993   to a printer
3994 ****************************************************************************/
3995
3996 BOOL printer_driver_in_use ( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info_3 )
3997 {
3998         int snum;
3999         int n_services = lp_numservices();
4000         NT_PRINTER_INFO_LEVEL *printer = NULL;
4001
4002         if ( !info_3 )
4003                 return False;
4004
4005         DEBUG(5,("printer_driver_in_use: Beginning search through ntprinters.tdb...\n"));
4006
4007         /* loop through the printers.tdb and check for the drivername */
4008
4009         for (snum=0; snum<n_services; snum++)
4010         {
4011                 if ( !(lp_snum_ok(snum) && lp_print_ok(snum) ) )
4012                         continue;
4013
4014                 if ( !W_ERROR_IS_OK(get_a_printer(&printer, 2, lp_servicename(snum))) )
4015                         continue;
4016
4017                 if ( !StrCaseCmp(info_3->name, printer->info_2->drivername) ) {
4018                         free_a_printer( &printer, 2 );
4019                         return True;
4020                 }
4021
4022                 free_a_printer( &printer, 2 );
4023         }
4024
4025         DEBUG(5,("printer_driver_in_use: Completed search through ntprinters.tdb...\n"));
4026
4027         /* report that the driver is not in use by default */
4028
4029         return False;
4030 }
4031
4032
4033 /**********************************************************************
4034  Check to see if a ogiven file is in use by *info
4035  *********************************************************************/
4036
4037 static BOOL drv_file_in_use( char* file, NT_PRINTER_DRIVER_INFO_LEVEL_3 *info )
4038 {
4039         int i = 0;
4040
4041         if ( !info )
4042                 return False;
4043
4044         if ( strequal(file, info->driverpath) )
4045                 return True;
4046
4047         if ( strequal(file, info->datafile) )
4048                 return True;
4049
4050         if ( strequal(file, info->configfile) )
4051                 return True;
4052
4053         if ( strequal(file, info->helpfile) )
4054                 return True;
4055
4056         /* see of there are any dependent files to examine */
4057
4058         if ( !info->dependentfiles )
4059                 return False;
4060
4061         while ( *info->dependentfiles[i] )
4062         {
4063                 if ( strequal(file, info->dependentfiles[i]) )
4064                         return True;
4065
4066                 i++;
4067         }
4068
4069         return False;
4070
4071 }
4072
4073 /**********************************************************************
4074  Utility function to remove the dependent file pointed to by the
4075  input parameter from the list
4076  *********************************************************************/
4077
4078 static void trim_dependent_file( fstring files[], int idx )
4079 {
4080
4081         /* bump everything down a slot */
4082
4083         while( *files[idx+1] )
4084         {
4085                 fstrcpy( files[idx], files[idx+1] );
4086                 idx++;
4087         }
4088
4089         *files[idx] = '\0';
4090
4091         return;
4092 }
4093
4094 /**********************************************************************
4095  Check if any of the files used by src are also used by drv
4096  *********************************************************************/
4097
4098 static BOOL trim_overlap_drv_files( NT_PRINTER_DRIVER_INFO_LEVEL_3 *src,
4099                                        NT_PRINTER_DRIVER_INFO_LEVEL_3 *drv )
4100 {
4101         BOOL    in_use = False;
4102         int     i = 0;
4103
4104         if ( !src || !drv )
4105                 return False;
4106
4107         /* check each file.  Remove it from the src structure if it overlaps */
4108
4109         if ( drv_file_in_use(src->driverpath, drv) ) {
4110                 in_use = True;
4111                 DEBUG(10,("Removing driverfile [%s] from list\n", src->driverpath));
4112                 fstrcpy( src->driverpath, "" );
4113         }
4114
4115         if ( drv_file_in_use(src->datafile, drv) ) {
4116                 in_use = True;
4117                 DEBUG(10,("Removing datafile [%s] from list\n", src->datafile));
4118                 fstrcpy( src->datafile, "" );
4119         }
4120
4121         if ( drv_file_in_use(src->configfile, drv) ) {
4122                 in_use = True;
4123                 DEBUG(10,("Removing configfile [%s] from list\n", src->configfile));
4124                 fstrcpy( src->configfile, "" );
4125         }
4126
4127         if ( drv_file_in_use(src->helpfile, drv) ) {
4128                 in_use = True;
4129                 DEBUG(10,("Removing helpfile [%s] from list\n", src->helpfile));
4130                 fstrcpy( src->helpfile, "" );
4131         }
4132
4133         /* are there any dependentfiles to examine? */
4134
4135         if ( !src->dependentfiles )
4136                 return in_use;
4137
4138         while ( *src->dependentfiles[i] )
4139         {
4140                 if ( drv_file_in_use(src->dependentfiles[i], drv) ) {
4141                         in_use = True;
4142                         DEBUG(10,("Removing [%s] from dependent file list\n", src->dependentfiles[i]));
4143                         trim_dependent_file( src->dependentfiles, i );
4144                 }
4145                 else
4146                         i++;
4147         }
4148
4149         return in_use;
4150 }
4151
4152 /****************************************************************************
4153   Determine whether or not a particular driver files are currently being
4154   used by any other driver.
4155
4156   Return value is True if any files were in use by other drivers
4157   and False otherwise.
4158
4159   Upon return, *info has been modified to only contain the driver files
4160   which are not in use
4161 ****************************************************************************/
4162
4163 BOOL printer_driver_files_in_use ( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info )
4164 {
4165         int                             i;
4166         int                             ndrivers;
4167         uint32                          version;
4168         fstring                         *list = NULL;
4169         NT_PRINTER_DRIVER_INFO_LEVEL    driver;
4170
4171         if ( !info )
4172                 return False;
4173
4174         version = info->cversion;
4175
4176         /* loop over all driver versions */
4177
4178         DEBUG(5,("printer_driver_files_in_use: Beginning search through ntdrivers.tdb...\n"));
4179
4180         /* get the list of drivers */
4181
4182         list = NULL;
4183         ndrivers = get_ntdrivers(&list, info->environment, version);
4184
4185         DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
4186                 ndrivers, info->environment, version));
4187
4188         /* check each driver for overlap in files */
4189
4190         for (i=0; i<ndrivers; i++)
4191         {
4192                 DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
4193
4194                 ZERO_STRUCT(driver);
4195
4196                 if ( !W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, list[i],
4197                         info->environment, version)) )
4198                 {
4199                         SAFE_FREE(list);
4200                         return True;
4201                 }
4202
4203                 /* check if d2 uses any files from d1 */
4204                 /* only if this is a different driver than the one being deleted */
4205
4206                 if ( !strequal(info->name, driver.info_3->name) )
4207                 {
4208                         if ( trim_overlap_drv_files(info, driver.info_3) ) {
4209                                 free_a_printer_driver(driver, 3);
4210                                 SAFE_FREE( list );
4211                                 return True;
4212                         }
4213                 }
4214
4215                 free_a_printer_driver(driver, 3);
4216         }
4217
4218         SAFE_FREE(list);
4219
4220         DEBUG(5,("printer_driver_files_in_use: Completed search through ntdrivers.tdb...\n"));
4221
4222         driver.info_3 = info;
4223
4224         if ( DEBUGLEVEL >= 20 )
4225                 dump_a_printer_driver( driver, 3 );
4226
4227         return False;
4228 }
4229
4230 /****************************************************************************
4231   Actually delete the driver files.  Make sure that
4232   printer_driver_files_in_use() return False before calling
4233   this.
4234 ****************************************************************************/
4235
4236 static BOOL delete_driver_files( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info_3, struct current_user *user )
4237 {
4238         int i = 0;
4239         char *s;
4240         connection_struct *conn;
4241         DATA_BLOB null_pw;
4242         NTSTATUS nt_status;
4243
4244         if ( !info_3 )
4245                 return False;
4246
4247         DEBUG(6,("delete_driver_files: deleting driver [%s] - version [%d]\n", info_3->name, info_3->cversion));
4248
4249         /*
4250          * Connect to the print$ share under the same account as the
4251          * user connected to the rpc pipe. Note we must be root to
4252          * do this.
4253          */
4254
4255         become_root();
4256         null_pw = data_blob( NULL, 0 );
4257         conn = make_connection_with_chdir( "print$", null_pw, "A:", user->vuid, &nt_status );
4258         unbecome_root();
4259
4260         if ( !conn ) {
4261                 DEBUG(0,("delete_driver_files: Unable to connect\n"));
4262                 return False;
4263         }
4264
4265         /* Save who we are - we are temporarily becoming the connection user. */
4266
4267         if ( !become_user(conn, conn->vuid) ) {
4268                 DEBUG(0,("delete_driver_files: Can't become user!\n"));
4269                 return False;
4270         }
4271
4272         /* now delete the files; must strip the '\print$' string from
4273            fron of path                                                */
4274
4275         if ( *info_3->driverpath ) {
4276                 if ( (s = strchr( &info_3->driverpath[1], '\\' )) != NULL ) {
4277                         DEBUG(10,("deleting driverfile [%s]\n", s));
4278                         unlink_internals(conn, 0, s);
4279                 }
4280         }
4281
4282         if ( *info_3->configfile ) {
4283                 if ( (s = strchr( &info_3->configfile[1], '\\' )) != NULL ) {
4284                         DEBUG(10,("deleting configfile [%s]\n", s));
4285                         unlink_internals(conn, 0, s);
4286                 }
4287         }
4288
4289         if ( *info_3->datafile ) {
4290                 if ( (s = strchr( &info_3->datafile[1], '\\' )) != NULL ) {
4291                         DEBUG(10,("deleting datafile [%s]\n", s));
4292                         unlink_internals(conn, 0, s);
4293                 }
4294         }
4295
4296         if ( *info_3->helpfile ) {
4297                 if ( (s = strchr( &info_3->helpfile[1], '\\' )) != NULL ) {
4298                         DEBUG(10,("deleting helpfile [%s]\n", s));
4299                         unlink_internals(conn, 0, s);
4300                 }
4301         }
4302
4303         /* check if we are done removing files */
4304
4305         if ( info_3->dependentfiles )
4306         {
4307                 while ( *info_3->dependentfiles[i] ) {
4308                         char *file;
4309
4310                         /* bypass the "\print$" portion of the path */
4311
4312                         if ( (file = strchr( info_3->dependentfiles[i]+1, '\\' )) != NULL )
4313                         {
4314                                 DEBUG(10,("deleting dependent file [%s]\n", file));
4315                                 unlink_internals(conn, 0, file );
4316                         }
4317
4318                         i++;
4319                 }
4320         }
4321
4322         unbecome_user();
4323
4324         return True;
4325 }
4326
4327 /****************************************************************************
4328  Remove a printer driver from the TDB.  This assumes that the the driver was
4329  previously looked up.
4330  ***************************************************************************/
4331
4332 WERROR delete_printer_driver( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info_3, struct current_user *user,
4333                               uint32 version, BOOL delete_files )
4334 {
4335         pstring         key;
4336         fstring         arch;
4337         TDB_DATA        kbuf, dbuf;
4338         NT_PRINTER_DRIVER_INFO_LEVEL    ctr;
4339
4340         /* delete the tdb data first */
4341
4342         get_short_archi(arch, info_3->environment);
4343         slprintf(key, sizeof(key)-1, "%s%s/%d/%s", DRIVERS_PREFIX,
4344                 arch, version, info_3->name);
4345
4346         DEBUG(5,("delete_printer_driver: key = [%s] delete_files = %s\n",
4347                 key, delete_files ? "TRUE" : "FALSE" ));
4348
4349         ctr.info_3 = info_3;
4350         dump_a_printer_driver( ctr, 3 );
4351
4352         kbuf.dptr=key;
4353         kbuf.dsize=strlen(key)+1;
4354
4355         /* check if the driver actually exists for this environment */
4356
4357         dbuf = tdb_fetch( tdb_drivers, kbuf );
4358         if ( !dbuf.dptr ) {
4359                 DEBUG(8,("delete_printer_driver: Driver unknown [%s]\n", key));
4360                 return WERR_UNKNOWN_PRINTER_DRIVER;
4361         }
4362
4363         SAFE_FREE( dbuf.dptr );
4364
4365         /* ok... the driver exists so the delete should return success */
4366
4367         if (tdb_delete(tdb_drivers, kbuf) == -1) {
4368                 DEBUG (0,("delete_printer_driver: fail to delete %s!\n", key));
4369                 return WERR_ACCESS_DENIED;
4370         }
4371
4372         /*
4373          * now delete any associated files if delete_files == True
4374          * even if this part failes, we return succes because the
4375          * driver doesn not exist any more
4376          */
4377
4378         if ( delete_files )
4379                 delete_driver_files( info_3, user );
4380
4381
4382         DEBUG(5,("delete_printer_driver: driver delete successful [%s]\n", key));
4383
4384         return WERR_OK;
4385         }
4386
4387 /****************************************************************************
4388  Store a security desc for a printer.
4389 ****************************************************************************/
4390
4391 WERROR nt_printing_setsec(const char *printername, SEC_DESC_BUF *secdesc_ctr)
4392 {
4393         SEC_DESC_BUF *new_secdesc_ctr = NULL;
4394         SEC_DESC_BUF *old_secdesc_ctr = NULL;
4395         prs_struct ps;
4396         TALLOC_CTX *mem_ctx = NULL;
4397         fstring key;
4398         WERROR status;
4399
4400         mem_ctx = talloc_init("nt_printing_setsec");
4401         if (mem_ctx == NULL)
4402                 return WERR_NOMEM;
4403
4404         /* The old owner and group sids of the security descriptor are not
4405            present when new ACEs are added or removed by changing printer
4406            permissions through NT.  If they are NULL in the new security
4407            descriptor then copy them over from the old one. */
4408
4409         if (!secdesc_ctr->sec->owner_sid || !secdesc_ctr->sec->grp_sid) {
4410                 DOM_SID *owner_sid, *group_sid;
4411                 SEC_ACL *dacl, *sacl;
4412                 SEC_DESC *psd = NULL;
4413                 size_t size;
4414
4415                 nt_printing_getsec(mem_ctx, printername, &old_secdesc_ctr);
4416
4417                 /* Pick out correct owner and group sids */
4418
4419                 owner_sid = secdesc_ctr->sec->owner_sid ?
4420                         secdesc_ctr->sec->owner_sid :
4421                         old_secdesc_ctr->sec->owner_sid;
4422
4423                 group_sid = secdesc_ctr->sec->grp_sid ?
4424                         secdesc_ctr->sec->grp_sid :
4425                         old_secdesc_ctr->sec->grp_sid;
4426
4427                 dacl = secdesc_ctr->sec->dacl ?
4428                         secdesc_ctr->sec->dacl :
4429                         old_secdesc_ctr->sec->dacl;
4430
4431                 sacl = secdesc_ctr->sec->sacl ?
4432                         secdesc_ctr->sec->sacl :
4433                         old_secdesc_ctr->sec->sacl;
4434
4435                 /* Make a deep copy of the security descriptor */
4436
4437                 psd = make_sec_desc(mem_ctx, secdesc_ctr->sec->revision,
4438                                     owner_sid, group_sid,
4439                                     sacl,
4440                                     dacl,
4441                                     &size);
4442
4443                 new_secdesc_ctr = make_sec_desc_buf(mem_ctx, size, psd);
4444         }
4445
4446         if (!new_secdesc_ctr) {
4447                 new_secdesc_ctr = secdesc_ctr;
4448         }
4449
4450         /* Store the security descriptor in a tdb */
4451
4452         prs_init(&ps, (uint32)sec_desc_size(new_secdesc_ctr->sec) +
4453                  sizeof(SEC_DESC_BUF), mem_ctx, MARSHALL);
4454
4455         if (!sec_io_desc_buf("nt_printing_setsec", &new_secdesc_ctr,
4456                              &ps, 1)) {
4457                 status = WERR_BADFUNC;
4458                 goto out;
4459         }
4460
4461         slprintf(key, sizeof(key)-1, "SECDESC/%s", printername);
4462
4463         if (tdb_prs_store(tdb_printers, key, &ps)==0) {
4464                 status = WERR_OK;
4465         } else {
4466                 DEBUG(1,("Failed to store secdesc for %s\n", printername));
4467                 status = WERR_BADFUNC;
4468         }
4469
4470         /* Free malloc'ed memory */
4471
4472  out:
4473
4474         prs_mem_free(&ps);
4475         if (mem_ctx)
4476                 talloc_destroy(mem_ctx);
4477         return status;
4478 }
4479
4480 /****************************************************************************
4481  Construct a default security descriptor buffer for a printer.
4482 ****************************************************************************/
4483
4484 static SEC_DESC_BUF *construct_default_printer_sdb(TALLOC_CTX *ctx)
4485 {
4486         SEC_ACE ace[3];
4487         SEC_ACCESS sa;
4488         SEC_ACL *psa = NULL;
4489         SEC_DESC_BUF *sdb = NULL;
4490         SEC_DESC *psd = NULL;
4491         DOM_SID owner_sid;
4492         size_t sd_size;
4493
4494         /* Create an ACE where Everyone is allowed to print */
4495
4496         init_sec_access(&sa, PRINTER_ACE_PRINT);
4497         init_sec_ace(&ace[0], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED,
4498                      sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
4499
4500         /* Make the security descriptor owned by the Administrators group
4501            on the PDC of the domain. */
4502
4503         if (secrets_fetch_domain_sid(lp_workgroup(), &owner_sid)) {
4504                 sid_append_rid(&owner_sid, DOMAIN_USER_RID_ADMIN);
4505         } else {
4506
4507                 /* Backup plan - make printer owned by admins.
4508                    This should emulate a lanman printer as security
4509                    settings can't be changed. */
4510
4511                 sid_copy(&owner_sid, get_global_sam_sid());
4512                 sid_append_rid(&owner_sid, DOMAIN_USER_RID_ADMIN);
4513         }
4514
4515         init_sec_access(&sa, PRINTER_ACE_FULL_CONTROL);
4516         init_sec_ace(&ace[1], &owner_sid, SEC_ACE_TYPE_ACCESS_ALLOWED,
4517                      sa, SEC_ACE_FLAG_OBJECT_INHERIT |
4518                      SEC_ACE_FLAG_INHERIT_ONLY);
4519
4520         init_sec_access(&sa, PRINTER_ACE_FULL_CONTROL);
4521         init_sec_ace(&ace[2], &owner_sid, SEC_ACE_TYPE_ACCESS_ALLOWED,
4522                      sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
4523
4524         /* The ACL revision number in rpc_secdesc.h differs from the one
4525            created by NT when setting ACE entries in printer
4526            descriptors.  NT4 complains about the property being edited by a
4527            NT5 machine. */
4528
4529         if ((psa = make_sec_acl(ctx, NT4_ACL_REVISION, 3, ace)) != NULL) {
4530                 psd = make_sec_desc(ctx, SEC_DESC_REVISION,
4531                                     &owner_sid, NULL,
4532                                     NULL, psa, &sd_size);
4533         }
4534
4535         if (!psd) {
4536                 DEBUG(0,("construct_default_printer_sd: Failed to make SEC_DESC.\n"));
4537                 return NULL;
4538         }
4539
4540         sdb = make_sec_desc_buf(ctx, sd_size, psd);
4541
4542         DEBUG(4,("construct_default_printer_sdb: size = %u.\n",
4543                  (unsigned int)sd_size));
4544
4545         return sdb;
4546 }
4547
4548 /****************************************************************************
4549  Get a security desc for a printer.
4550 ****************************************************************************/
4551
4552 BOOL nt_printing_getsec(TALLOC_CTX *ctx, const char *printername, SEC_DESC_BUF **secdesc_ctr)
4553 {
4554         prs_struct ps;
4555         fstring key;
4556         char *temp;
4557
4558         if (strlen(printername) > 2 && (temp = strchr(printername + 2, '\\')))
4559                 printername = temp + 1;
4560
4561         /* Fetch security descriptor from tdb */
4562
4563         slprintf(key, sizeof(key)-1, "SECDESC/%s", printername);
4564
4565         if (tdb_prs_fetch(tdb_printers, key, &ps, ctx)!=0 ||
4566             !sec_io_desc_buf("nt_printing_getsec", secdesc_ctr, &ps, 1)) {
4567
4568                 DEBUG(4,("using default secdesc for %s\n", printername));
4569
4570                 if (!(*secdesc_ctr = construct_default_printer_sdb(ctx))) {
4571                         return False;
4572                 }
4573
4574                 /* Save default security descriptor for later */
4575
4576                 prs_init(&ps, (uint32)sec_desc_size((*secdesc_ctr)->sec) +
4577                                 sizeof(SEC_DESC_BUF), ctx, MARSHALL);
4578
4579                 if (sec_io_desc_buf("nt_printing_getsec", secdesc_ctr, &ps, 1))
4580                         tdb_prs_store(tdb_printers, key, &ps);
4581
4582                 prs_mem_free(&ps);
4583
4584                 return True;
4585         }
4586
4587         /* If security descriptor is owned by S-1-1-0 and winbindd is up,
4588            this security descriptor has been created when winbindd was
4589            down.  Take ownership of security descriptor. */
4590
4591         if (sid_equal((*secdesc_ctr)->sec->owner_sid, &global_sid_World)) {
4592                 DOM_SID owner_sid;
4593
4594                 /* Change sd owner to workgroup administrator */
4595
4596                 if (secrets_fetch_domain_sid(lp_workgroup(), &owner_sid)) {
4597                         SEC_DESC_BUF *new_secdesc_ctr = NULL;
4598                         SEC_DESC *psd = NULL;
4599                         size_t size;
4600
4601                         /* Create new sd */
4602
4603                         sid_append_rid(&owner_sid, DOMAIN_USER_RID_ADMIN);
4604
4605                         psd = make_sec_desc(ctx, (*secdesc_ctr)->sec->revision,
4606                                             &owner_sid,
4607                                             (*secdesc_ctr)->sec->grp_sid,
4608                                             (*secdesc_ctr)->sec->sacl,
4609                                             (*secdesc_ctr)->sec->dacl,
4610                                             &size);
4611
4612                         new_secdesc_ctr = make_sec_desc_buf(ctx, size, psd);
4613
4614                         /* Swap with other one */
4615
4616                         *secdesc_ctr = new_secdesc_ctr;
4617
4618                         /* Set it */
4619
4620                         nt_printing_setsec(printername, *secdesc_ctr);
4621                 }
4622         }
4623
4624         if (DEBUGLEVEL >= 10) {
4625                 SEC_ACL *the_acl = (*secdesc_ctr)->sec->dacl;
4626                 int i;
4627
4628                 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
4629                            printername, the_acl->num_aces));
4630
4631                 for (i = 0; i < the_acl->num_aces; i++) {
4632                         fstring sid_str;
4633
4634                         sid_to_string(sid_str, &the_acl->ace[i].trustee);
4635
4636                         DEBUG(10, ("%s %d %d 0x%08x\n", sid_str,
4637                                    the_acl->ace[i].type, the_acl->ace[i].flags,
4638                                    the_acl->ace[i].info.mask));
4639                 }
4640         }
4641
4642         prs_mem_free(&ps);
4643         return True;
4644 }
4645
4646 /* error code:
4647         0: everything OK
4648         1: level not implemented
4649         2: file doesn't exist
4650         3: can't allocate memory
4651         4: can't free memory
4652         5: non existant struct
4653 */
4654
4655 /*
4656         A printer and a printer driver are 2 different things.
4657         NT manages them separatelly, Samba does the same.
4658         Why ? Simply because it's easier and it makes sense !
4659
4660         Now explanation: You have 3 printers behind your samba server,
4661         2 of them are the same make and model (laser A and B). But laser B
4662         has an 3000 sheet feeder and laser A doesn't such an option.
4663         Your third printer is an old dot-matrix model for the accounting :-).
4664
4665         If the /usr/local/samba/lib directory (default dir), you will have
4666         5 files to describe all of this.
4667
4668         3 files for the printers (1 by printer):
4669                 NTprinter_laser A
4670                 NTprinter_laser B
4671                 NTprinter_accounting
4672         2 files for the drivers (1 for the laser and 1 for the dot matrix)
4673                 NTdriver_printer model X
4674                 NTdriver_printer model Y
4675
4676 jfm: I should use this comment for the text file to explain
4677         same thing for the forms BTW.
4678         Je devrais mettre mes commentaires en francais, ca serait mieux :-)
4679
4680 */
4681
4682 /* Convert generic access rights to printer object specific access rights.
4683    It turns out that NT4 security descriptors use generic access rights and
4684    NT5 the object specific ones. */
4685
4686 void map_printer_permissions(SEC_DESC *sd)
4687 {
4688         int i;
4689
4690         for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) {
4691                 se_map_generic(&sd->dacl->ace[i].info.mask,
4692                                &printer_generic_mapping);
4693         }
4694 }
4695
4696 /****************************************************************************
4697  Check a user has permissions to perform the given operation.  We use the
4698  permission constants defined in include/rpc_spoolss.h to check the various
4699  actions we perform when checking printer access.
4700
4701    PRINTER_ACCESS_ADMINISTER:
4702        print_queue_pause, print_queue_resume, update_printer_sec,
4703        update_printer, spoolss_addprinterex_level_2,
4704        _spoolss_setprinterdata
4705
4706    PRINTER_ACCESS_USE:
4707        print_job_start
4708
4709    JOB_ACCESS_ADMINISTER:
4710        print_job_delete, print_job_pause, print_job_resume,
4711        print_queue_purge
4712
4713  ****************************************************************************/
4714 BOOL print_access_check(struct current_user *user, int snum, int access_type)
4715 {
4716         SEC_DESC_BUF *secdesc = NULL;
4717         uint32 access_granted;
4718         NTSTATUS status;
4719         BOOL result;
4720         const char *pname;
4721         TALLOC_CTX *mem_ctx = NULL;
4722         extern struct current_user current_user;
4723
4724         /* If user is NULL then use the current_user structure */
4725
4726         if (!user)
4727                 user = &current_user;
4728
4729         /* Always allow root or printer admins to do anything */
4730
4731         if (user->uid == 0 ||
4732             user_in_list(uidtoname(user->uid), lp_printer_admin(snum))) {
4733                 return True;
4734         }
4735
4736         /* Get printer name */
4737
4738         pname = PRINTERNAME(snum);
4739
4740         if (!pname || !*pname) {
4741                 errno = EACCES;
4742                 return False;
4743         }
4744
4745         /* Get printer security descriptor */
4746
4747         if(!(mem_ctx = talloc_init("print_access_check"))) {
4748                 errno = ENOMEM;
4749                 return False;
4750         }
4751
4752         nt_printing_getsec(mem_ctx, pname, &secdesc);
4753
4754         if (access_type == JOB_ACCESS_ADMINISTER) {
4755                 SEC_DESC_BUF *parent_secdesc = secdesc;
4756
4757                 /* Create a child security descriptor to check permissions
4758                    against.  This is because print jobs are child objects
4759                    objects of a printer. */
4760
4761                 secdesc = se_create_child_secdesc(mem_ctx, parent_secdesc->sec, False);
4762
4763                 /* Now this is the bit that really confuses me.  The access
4764                    type needs to be changed from JOB_ACCESS_ADMINISTER to
4765                    PRINTER_ACCESS_ADMINISTER for this to work.  Something
4766                    to do with the child (job) object becoming like a
4767                    printer??  -tpot */
4768
4769                 access_type = PRINTER_ACCESS_ADMINISTER;
4770         }
4771
4772         /* Check access */
4773
4774         map_printer_permissions(secdesc->sec);
4775
4776         result = se_access_check(secdesc->sec, user->nt_user_token, access_type,
4777                                  &access_granted, &status);
4778
4779         DEBUG(4, ("access check was %s\n", result ? "SUCCESS" : "FAILURE"));
4780
4781         talloc_destroy(mem_ctx);
4782
4783         if (!result)
4784                 errno = EACCES;
4785
4786         return result;
4787 }
4788
4789 /****************************************************************************
4790  Check the time parameters allow a print operation.
4791 *****************************************************************************/
4792
4793 BOOL print_time_access_check(int snum)
4794 {
4795         NT_PRINTER_INFO_LEVEL *printer = NULL;
4796         BOOL ok = False;
4797         time_t now = time(NULL);
4798         struct tm *t;
4799         uint32 mins;
4800
4801         if (!W_ERROR_IS_OK(get_a_printer(&printer, 2, lp_servicename(snum))))
4802                 return False;
4803
4804         if (printer->info_2->starttime == 0 && printer->info_2->untiltime == 0)
4805                 ok = True;
4806
4807         t = gmtime(&now);
4808         mins = (uint32)t->tm_hour*60 + (uint32)t->tm_min;
4809
4810         if (mins >= printer->info_2->starttime && mins <= printer->info_2->untiltime)
4811                 ok = True;
4812
4813         free_a_printer(&printer, 2);
4814
4815         if (!ok)
4816                 errno = EACCES;
4817
4818         return ok;
4819 }
4820