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         for (i=0; i < info2->data.num_keys; i++)
2512                 if (!(StrCaseCmp(SPOOL_DSSPOOLER_KEY,
2513                                  info2->data.keys[i].name)))
2514                         ctr = &info2->data.keys[i].values;
2515
2516         if (!ctr) {
2517                 add_new_printer_key(&info2->data, SPOOL_DSSPOOLER_KEY);
2518                 ctr = &info2->data.keys[info2->data.num_keys - 1].values;
2519         }
2520
2521         map_sz_into_ctr(ctr, SPOOL_REG_PRINTERNAME, info2->sharename);
2522         map_sz_into_ctr(ctr, SPOOL_REG_SHORTSERVERNAME, global_myname());
2523
2524         get_myfullname(longname);
2525         map_sz_into_ctr(ctr, SPOOL_REG_SERVERNAME, longname);
2526
2527         asprintf(&ascii_str, "\\\\%s\\%s", longname, info2->sharename);
2528         map_sz_into_ctr(ctr, SPOOL_REG_UNCNAME, ascii_str);
2529         safe_free(ascii_str);
2530
2531
2532         map_dword_into_ctr(ctr, SPOOL_REG_VERSIONNUMBER, 4);
2533         map_sz_into_ctr(ctr, SPOOL_REG_DRIVERNAME, info2->drivername);
2534         map_sz_into_ctr(ctr, SPOOL_REG_LOCATION, info2->location);
2535         map_sz_into_ctr(ctr, SPOOL_REG_DESCRIPTION, info2->comment);
2536         map_single_multi_sz_into_ctr(ctr, SPOOL_REG_PORTNAME, info2->portname);
2537         map_sz_into_ctr(ctr, SPOOL_REG_PRINTSEPARATORFILE, info2->sepfile);
2538         map_dword_into_ctr(ctr, SPOOL_REG_PRINTSTARTTIME, info2->starttime);
2539         map_dword_into_ctr(ctr, SPOOL_REG_PRINTENDTIME, info2->untiltime);
2540         map_dword_into_ctr(ctr, SPOOL_REG_PRIORITY, info2->priority);
2541
2542         map_bool_into_ctr(ctr, SPOOL_REG_PRINTKEEPPRINTEDJOBS,
2543                           (info2->attributes &
2544                            PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS));
2545
2546         switch (info2->attributes & 0x3) {
2547         case 0:
2548                 ascii_str = SPOOL_REGVAL_PRINTWHILESPOOLING;
2549                 break;
2550         case 1:
2551                 ascii_str = SPOOL_REGVAL_PRINTAFTERSPOOLED;
2552                 break;
2553         case 2:
2554                 ascii_str = SPOOL_REGVAL_PRINTDIRECT;
2555                 break;
2556         default:
2557                 ascii_str = "unknown";
2558         }
2559         map_sz_into_ctr(ctr, SPOOL_REG_PRINTSPOOLING, ascii_str);
2560
2561         return True;
2562 }
2563
2564 /****************************************************************************
2565  * Publish a printer in the directory
2566  *
2567  * @param snum describing printer service
2568  * @return WERROR indicating status of publishing
2569  ***************************************************************************/
2570
2571 WERROR nt_printer_publish(int snum, int action)
2572 {
2573 #ifdef HAVE_ADS
2574         NT_PRINTER_INFO_LEVEL *printer = NULL;
2575         WERROR win_rc;
2576         ADS_STATUS ads_rc;
2577         TALLOC_CTX *ctx = talloc_init();
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
2583         win_rc = get_a_printer(&printer, 2, lp_servicename(snum));
2584         if (!W_ERROR_IS_OK(win_rc))
2585                 return win_rc;
2586
2587         if ((SPOOL_DS_PUBLISH == action) || (SPOOL_DS_UPDATE == action)) {
2588                 if (!(map_nt_printer_info2_to_dsspooler(printer->info_2)))
2589                         return WERR_NOMEM;
2590
2591                 printer->info_2->attributes |= PRINTER_ATTRIBUTE_PUBLISHED;
2592
2593                 win_rc = mod_a_printer(*printer, 2);
2594                 if (!W_ERROR_IS_OK(win_rc)) {
2595                         DEBUG(3, ("nt_printer_publish: err %d saving data\n",
2596                                   W_ERROR_V(win_rc)));
2597                         free_a_printer(&printer, 2);
2598                         return win_rc;
2599                 }
2600
2601                 get_local_printer_publishing_data(ctx, &mods,
2602                                                   &printer->info_2->data);
2603                 ads_mod_str(ctx, &mods, SPOOL_REG_PRINTERNAME,
2604                             lp_servicename(snum));
2605         } else {
2606                 printer->info_2->attributes ^= PRINTER_ATTRIBUTE_PUBLISHED;
2607                 win_rc = mod_a_printer(*printer, 2);
2608                 if (!W_ERROR_IS_OK(win_rc)) {
2609                         DEBUG(3, ("nt_printer_publish: err %d saving data\n",
2610                                   W_ERROR_V(win_rc)));
2611                         free_a_printer(&printer, 2);
2612                         return win_rc;
2613                 }
2614         }
2615
2616         ads = ads_init(NULL, NULL, lp_ads_server());
2617
2618         ads_rc = ads_connect(ads);
2619
2620         if (SPOOL_DS_UNPUBLISH == action) {
2621                 ads_rc = ads_find_printer_on_server(ads, &res,
2622                                 printer->info_2->sharename, global_myname());
2623                 if (ADS_ERR_OK(ads_rc) && ads_count_replies(ads, res)) {
2624                                 prt_dn = ads_get_dn(ads, res);
2625                                 ads_msgfree(ads, res);
2626                                 ads_rc = ads_del_dn(ads, prt_dn);
2627                                 ads_memfree(ads, prt_dn);
2628                 }
2629         }
2630
2631         if ((SPOOL_DS_PUBLISH == action) || (SPOOL_DS_UPDATE == action)) {
2632                 ads_find_machine_acct(ads, &res, global_myname());
2633                 srv_dn = ldap_get_dn(ads->ld, res);
2634                 ads_msgfree(ads, res);
2635                 srv_cn = ldap_explode_dn(srv_dn, 1);
2636                 asprintf(&prt_dn, "cn=%s-%s,%s", srv_cn[0],
2637                          printer->info_2->sharename, srv_dn);
2638                 ads_memfree(ads, srv_dn);
2639
2640                 ads_rc = ads_add_printer_entry(ads, prt_dn, ctx, &mods);
2641                 if (LDAP_ALREADY_EXISTS == ads_rc.err.rc)
2642                         ads_rc = ads_mod_printer_entry(ads, prt_dn, ctx,&mods);
2643                 safe_free(prt_dn);
2644                 ads_destroy(&ads);
2645         }
2646
2647         free_a_printer(&printer, 2);
2648         return WERR_OK;
2649 #else
2650         return WERR_OK;
2651 #endif
2652 }
2653
2654 /****************************************************************************
2655  ***************************************************************************/
2656
2657 WERROR delete_all_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, char *key )
2658 {
2659         NT_PRINTER_DATA *data;
2660         int             i;
2661         int             removed_keys = 0;
2662         int             empty_slot;
2663
2664         data = &p2->data;
2665         empty_slot = data->num_keys;
2666
2667         if ( !key )
2668                 return WERR_INVALID_PARAM;
2669
2670         /* remove all keys */
2671
2672         if ( !strlen(key) )
2673         {
2674                 for ( i=0; i<data->num_keys; i++ )
2675                 {
2676                         DEBUG(8,("delete_all_printer_data: Removed all Printer Data from key [%s]\n",
2677                                 data->keys[i].name));
2678
2679                         SAFE_FREE( data->keys[i].name );
2680                         regval_ctr_destroy( &data->keys[i].values );
2681                 }
2682
2683                 DEBUG(8,("delete_all_printer_data: Removed all Printer Data from printer [%s]\n",
2684                         p2->printername ));
2685
2686                 SAFE_FREE( data->keys );
2687                 ZERO_STRUCTP( data );
2688
2689                 return WERR_OK;
2690         }
2691
2692         /* remove a specific key (and all subkeys) */
2693
2694         for ( i=0; i<data->num_keys; i++ )
2695         {
2696                 if ( StrnCaseCmp( data->keys[i].name, key, strlen(key)) == 0 )
2697                 {
2698                         DEBUG(8,("delete_all_printer_data: Removed all Printer Data from key [%s]\n",
2699                                 data->keys[i].name));
2700
2701                         SAFE_FREE( data->keys[i].name );
2702                         regval_ctr_destroy( &data->keys[i].values );
2703
2704                         /* mark the slot as empty */
2705
2706                         ZERO_STRUCTP( &data->keys[i] );
2707                 }
2708         }
2709
2710         /* find the first empty slot */
2711
2712         for ( i=0; i<data->num_keys; i++ ) {
2713                 if ( !data->keys[i].name ) {
2714                         empty_slot = i;
2715                         removed_keys++;
2716                         break;
2717                 }
2718         }
2719
2720         if ( i == data->num_keys )
2721                 /* nothing was removed */
2722                 return WERR_INVALID_PARAM;
2723
2724         /* move everything down */
2725
2726         for ( i=empty_slot+1; i<data->num_keys; i++ ) {
2727                 if ( data->keys[i].name ) {
2728                         memcpy( &data->keys[empty_slot], &data->keys[i], sizeof(NT_PRINTER_KEY) );
2729                         ZERO_STRUCTP( &data->keys[i] );
2730                         empty_slot++;
2731                         removed_keys++;
2732                 }
2733         }
2734
2735         /* update count */
2736
2737         data->num_keys -= removed_keys;
2738
2739         /* sanity check to see if anything is left */
2740
2741         if ( !data->num_keys )
2742         {
2743                 DEBUG(8,("delete_all_printer_data: No keys left for printer [%s]\n", p2->printername ));
2744
2745                 SAFE_FREE( data->keys );
2746                 ZERO_STRUCTP( data );
2747         }
2748
2749         return WERR_OK;
2750 }
2751
2752 /****************************************************************************
2753  ***************************************************************************/
2754
2755 WERROR delete_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, char *key, char *value )
2756 {
2757         WERROR          result = WERR_OK;
2758         int             key_index;
2759
2760         /* we must have names on non-zero length */
2761
2762         if ( !key || !*key|| !value || !*value )
2763                 return WERR_INVALID_NAME;
2764
2765         /* find the printer key first */
2766
2767         key_index = lookup_printerkey( &p2->data, key );
2768         if ( key_index == -1 )
2769                 return WERR_OK;
2770
2771         regval_ctr_delvalue( &p2->data.keys[key_index].values, value );
2772
2773         DEBUG(8,("delete_printer_data: Removed key => [%s], value => [%s]\n",
2774                 key, value ));
2775
2776         return result;
2777 }
2778
2779 /****************************************************************************
2780  ***************************************************************************/
2781
2782 WERROR add_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, char *key, char *value,
2783                            uint32 type, uint8 *data, int real_len )
2784 {
2785         WERROR          result = WERR_OK;
2786         int             key_index;
2787
2788         /* we must have names on non-zero length */
2789
2790         if ( !key || !*key|| !value || !*value )
2791                 return WERR_INVALID_NAME;
2792
2793         /* find the printer key first */
2794
2795         key_index = lookup_printerkey( &p2->data, key );
2796         if ( key_index == -1 )
2797                 key_index = add_new_printer_key( &p2->data, key );
2798
2799         if ( key_index == -1 )
2800                 return WERR_NOMEM;
2801
2802         regval_ctr_addvalue( &p2->data.keys[key_index].values, value,
2803                 type, data, real_len );
2804
2805         DEBUG(8,("add_printer_data: Added key => [%s], value => [%s], type=> [%d], size => [%d]\n",
2806                 key, value, type, real_len  ));
2807
2808         return result;
2809 }
2810
2811 /****************************************************************************
2812  ***************************************************************************/
2813
2814 REGISTRY_VALUE* get_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, char *key, char *value )
2815 {
2816         int             key_index;
2817
2818         if ( (key_index = lookup_printerkey( &p2->data, key )) == -1 )
2819                 return NULL;
2820
2821         DEBUG(8,("get_printer_data: Attempting to lookup key => [%s], value => [%s]\n",
2822                 key, value ));
2823
2824         return regval_ctr_getvalue( &p2->data.keys[key_index].values, value );
2825 }
2826
2827 /****************************************************************************
2828  Unpack a list of registry values frem the TDB
2829  ***************************************************************************/
2830
2831 static int unpack_values(NT_PRINTER_DATA *printer_data, char *buf, int buflen)
2832 {
2833         int             len = 0;
2834         uint32          type;
2835         pstring         string, valuename, keyname;
2836         char            *str;
2837         int             size;
2838         uint8           *data_p;
2839         REGISTRY_VALUE  *regval_p;
2840         int             key_index;
2841
2842         /* add the "PrinterDriverData" key first for performance reasons */
2843
2844         add_new_printer_key( printer_data, SPOOL_PRINTERDATA_KEY );
2845
2846         /* loop and unpack the rest of the registry values */
2847
2848         while ( True )
2849         {
2850
2851                 /* check to see if there are any more registry values */
2852
2853                 len += tdb_unpack(buf+len, buflen-len, "p", &regval_p);
2854                 if ( !regval_p )
2855                         break;
2856
2857                 /* unpack the next regval */
2858
2859                 len += tdb_unpack(buf+len, buflen-len, "fdB",
2860                                   string,
2861                                   &type,
2862                                   &size,
2863                                   &data_p);
2864
2865                 /*
2866                  * break of the keyname from the value name.
2867                  * Should only be one '\' in the string returned.
2868                  */
2869
2870                 str = strrchr( string, '\\');
2871
2872                 /* Put in "PrinterDriverData" is no key specified */
2873
2874                 if ( !str ) {
2875                         pstrcpy( keyname, SPOOL_PRINTERDATA_KEY );
2876                         pstrcpy( valuename, string );
2877                 }
2878                 else {
2879                         *str = '\0';
2880                         pstrcpy( keyname, string );
2881                         pstrcpy( valuename, str+1 );
2882                 }
2883
2884                 /* see if we need a new key */
2885
2886                 if ( (key_index=lookup_printerkey( printer_data, keyname )) == -1 )
2887                         key_index = add_new_printer_key( printer_data, keyname );
2888
2889                 if ( key_index == -1 ) {
2890                         DEBUG(0,("unpack_values: Failed to allocate a new key [%s]!\n",
2891                                 keyname));
2892                         break;
2893                 }
2894
2895                 /* add the new value */
2896
2897                 regval_ctr_addvalue( &printer_data->keys[key_index].values, valuename, type, data_p, size );
2898
2899                 SAFE_FREE(data_p); /* 'B' option to tdb_unpack does a malloc() */
2900                 DEBUG(8,("specific: [%s:%s], len: %d\n", keyname, valuename, size));
2901         }
2902
2903         return len;
2904 }
2905
2906 /****************************************************************************
2907  ***************************************************************************/
2908
2909 static void map_to_os2_driver(fstring drivername)
2910 {
2911         static BOOL initialised=False;
2912         static fstring last_from,last_to;
2913         char *mapfile = lp_os2_driver_map();
2914         char **lines = NULL;
2915         int numlines = 0;
2916         int i;
2917
2918         if (!strlen(drivername))
2919                 return;
2920
2921         if (!*mapfile)
2922                 return;
2923
2924         if (!initialised) {
2925                 *last_from = *last_to = 0;
2926                 initialised = True;
2927         }
2928
2929         if (strequal(drivername,last_from)) {
2930                 DEBUG(3,("Mapped Windows driver %s to OS/2 driver %s\n",drivername,last_to));
2931                 fstrcpy(drivername,last_to);
2932                 return;
2933         }
2934
2935         lines = file_lines_load(mapfile, &numlines);
2936         if (numlines == 0) {
2937                 DEBUG(0,("No entries in OS/2 driver map %s\n",mapfile));
2938                 return;
2939         }
2940
2941         DEBUG(4,("Scanning OS/2 driver map %s\n",mapfile));
2942
2943         for( i = 0; i < numlines; i++) {
2944                 char *nt_name = lines[i];
2945                 char *os2_name = strchr(nt_name,'=');
2946
2947                 if (!os2_name)
2948                         continue;
2949
2950                 *os2_name++ = 0;
2951
2952                 while (isspace(*nt_name))
2953                         nt_name++;
2954
2955                 if (!*nt_name || strchr("#;",*nt_name))
2956                         continue;
2957
2958                 {
2959                         int l = strlen(nt_name);
2960                         while (l && isspace(nt_name[l-1])) {
2961                                 nt_name[l-1] = 0;
2962                                 l--;
2963                         }
2964                 }
2965
2966                 while (isspace(*os2_name))
2967                         os2_name++;
2968
2969                 {
2970                         int l = strlen(os2_name);
2971                         while (l && isspace(os2_name[l-1])) {
2972                                 os2_name[l-1] = 0;
2973                                 l--;
2974                         }
2975                 }
2976
2977                 if (strequal(nt_name,drivername)) {
2978                         DEBUG(3,("Mapped windows driver %s to os2 driver%s\n",drivername,os2_name));
2979                         fstrcpy(last_from,drivername);
2980                         fstrcpy(last_to,os2_name);
2981                         fstrcpy(drivername,os2_name);
2982                         file_lines_free(lines);
2983                         return;
2984                 }
2985         }
2986
2987         file_lines_free(lines);
2988 }
2989
2990 /****************************************************************************
2991 get a default printer info 2 struct
2992 ****************************************************************************/
2993 static WERROR get_a_printer_2_default(NT_PRINTER_INFO_LEVEL_2 **info_ptr, fstring sharename)
2994 {
2995         int snum;
2996         NT_PRINTER_INFO_LEVEL_2 info;
2997
2998         ZERO_STRUCT(info);
2999
3000         snum = lp_servicenumber(sharename);
3001
3002         slprintf(info.servername, sizeof(info.servername)-1, "\\\\%s", get_called_name());
3003         slprintf(info.printername, sizeof(info.printername)-1, "\\\\%s\\%s",
3004                  get_called_name(), sharename);
3005         fstrcpy(info.sharename, sharename);
3006         fstrcpy(info.portname, SAMBA_PRINTER_PORT_NAME);
3007
3008         /* by setting the driver name to an empty string, a local NT admin
3009            can now run the **local** APW to install a local printer driver
3010            for a Samba shared printer in 2.2.  Without this, drivers **must** be
3011            installed on the Samba server for NT clients --jerry */
3012 #if 0   /* JERRY --do not uncomment-- */
3013         if (!*info.drivername)
3014                 fstrcpy(info.drivername, "NO DRIVER AVAILABLE FOR THIS PRINTER");
3015 #endif
3016
3017
3018         DEBUG(10,("get_a_printer_2_default: driver name set to [%s]\n", info.drivername));
3019
3020         pstrcpy(info.comment, "");
3021         fstrcpy(info.printprocessor, "winprint");
3022         fstrcpy(info.datatype, "RAW");
3023
3024         info.attributes = PRINTER_ATTRIBUTE_SHARED | PRINTER_ATTRIBUTE_NETWORK;      /* attributes */
3025
3026         info.starttime = 0; /* Minutes since 12:00am GMT */
3027         info.untiltime = 0; /* Minutes since 12:00am GMT */
3028         info.priority = 1;
3029         info.default_priority = 1;
3030         info.setuptime = (uint32)time(NULL);
3031
3032         /*
3033          * I changed this as I think it is better to have a generic
3034          * DEVMODE than to crash Win2k explorer.exe   --jerry
3035          * See the HP Deskjet 990c Win2k drivers for an example.
3036          *
3037          * However the default devmode appears to cause problems
3038          * with the HP CLJ 8500 PCL driver.  Hence the addition of
3039          * the "default devmode" parameter   --jerry 22/01/2002
3040          */
3041
3042         if (lp_default_devmode(snum)) {
3043                 if ((info.devmode = construct_nt_devicemode(info.printername)) == NULL)
3044                         goto fail;
3045         }
3046         else {
3047                 info.devmode = NULL;
3048         }
3049
3050         /* This will get the current RPC talloc context, but we should be
3051            passing this as a parameter... fixme... JRA ! */
3052
3053         if (!nt_printing_getsec(get_talloc_ctx(), sharename, &info.secdesc_buf))
3054                 goto fail;
3055
3056         *info_ptr = (NT_PRINTER_INFO_LEVEL_2 *)memdup(&info, sizeof(info));
3057         if (! *info_ptr) {
3058                 DEBUG(0,("get_a_printer_2_default: malloc fail.\n"));
3059                 goto fail;
3060         }
3061
3062         return WERR_OK;
3063
3064   fail:
3065         if (info.devmode)
3066                 free_nt_devicemode(&info.devmode);
3067         return WERR_ACCESS_DENIED;
3068 }
3069
3070 /****************************************************************************
3071 ****************************************************************************/
3072 static WERROR get_a_printer_2(NT_PRINTER_INFO_LEVEL_2 **info_ptr, fstring sharename)
3073 {
3074         pstring key;
3075         NT_PRINTER_INFO_LEVEL_2 info;
3076         int             len = 0;
3077         TDB_DATA kbuf, dbuf;
3078         fstring printername;
3079
3080         ZERO_STRUCT(info);
3081
3082         slprintf(key, sizeof(key)-1, "%s%s", PRINTERS_PREFIX, sharename);
3083
3084         kbuf.dptr = key;
3085         kbuf.dsize = strlen(key)+1;
3086
3087         dbuf = tdb_fetch(tdb_printers, kbuf);
3088         if (!dbuf.dptr)
3089                 return get_a_printer_2_default(info_ptr, sharename);
3090
3091         len += tdb_unpack(dbuf.dptr+len, dbuf.dsize-len, "dddddddddddfffffPfffff",
3092                         &info.attributes,
3093                         &info.priority,
3094                         &info.default_priority,
3095                         &info.starttime,
3096                         &info.untiltime,
3097                         &info.status,
3098                         &info.cjobs,
3099                         &info.averageppm,
3100                         &info.changeid,
3101                         &info.c_setprinter,
3102                         &info.setuptime,
3103                         info.servername,
3104                         info.printername,
3105                         info.sharename,
3106                         info.portname,
3107                         info.drivername,
3108                         info.comment,
3109                         info.location,
3110                         info.sepfile,
3111                         info.printprocessor,
3112                         info.datatype,
3113                         info.parameters);
3114
3115         /* Samba has to have shared raw drivers. */
3116         info.attributes |= (PRINTER_ATTRIBUTE_SHARED | PRINTER_ATTRIBUTE_NETWORK);
3117
3118         /* Restore the stripped strings. */
3119         slprintf(info.servername, sizeof(info.servername)-1, "\\\\%s", get_called_name());
3120         slprintf(printername, sizeof(printername)-1, "\\\\%s\\%s", get_called_name(),
3121                         info.printername);
3122         fstrcpy(info.printername, printername);
3123
3124         len += unpack_devicemode(&info.devmode,dbuf.dptr+len, dbuf.dsize-len);
3125
3126         /*
3127          * Some client drivers freak out if there is a NULL devmode
3128          * (probably the driver is not checking before accessing
3129          * the devmode pointer)   --jerry
3130          *
3131          * See comments in get_a_printer_2_default()
3132          */
3133
3134         if (lp_default_devmode(lp_servicenumber(sharename)) && !info.devmode) {
3135                 DEBUG(8,("get_a_printer_2: Constructing a default device mode for [%s]\n",
3136                         printername));
3137                 info.devmode = construct_nt_devicemode(printername);
3138         }
3139
3140         len += unpack_values( &info.data, dbuf.dptr+len, dbuf.dsize-len );
3141
3142         /* This will get the current RPC talloc context, but we should be
3143            passing this as a parameter... fixme... JRA ! */
3144
3145         nt_printing_getsec(get_talloc_ctx(), sharename, &info.secdesc_buf);
3146
3147         /* Fix for OS/2 drivers. */
3148
3149         if (get_remote_arch() == RA_OS2)
3150                 map_to_os2_driver(info.drivername);
3151
3152         SAFE_FREE(dbuf.dptr);
3153         *info_ptr=memdup(&info, sizeof(info));
3154
3155         DEBUG(9,("Unpacked printer [%s] name [%s] running driver [%s]\n",
3156                  sharename, info.printername, info.drivername));
3157
3158         return WERR_OK;
3159 }
3160
3161 /****************************************************************************
3162 debugging function, dump at level 6 the struct in the logs
3163 ****************************************************************************/
3164 static uint32 dump_a_printer(NT_PRINTER_INFO_LEVEL printer, uint32 level)
3165 {
3166         uint32 result;
3167         NT_PRINTER_INFO_LEVEL_2 *info2;
3168
3169         DEBUG(106,("Dumping printer at level [%d]\n", level));
3170
3171         switch (level)
3172         {
3173                 case 2:
3174                 {
3175                         if (printer.info_2 == NULL)
3176                                 result=5;
3177                         else
3178                         {
3179                                 info2=printer.info_2;
3180
3181                                 DEBUGADD(106,("attributes:[%d]\n", info2->attributes));
3182                                 DEBUGADD(106,("priority:[%d]\n", info2->priority));
3183                                 DEBUGADD(106,("default_priority:[%d]\n", info2->default_priority));
3184                                 DEBUGADD(106,("starttime:[%d]\n", info2->starttime));
3185                                 DEBUGADD(106,("untiltime:[%d]\n", info2->untiltime));
3186                                 DEBUGADD(106,("status:[%d]\n", info2->status));
3187                                 DEBUGADD(106,("cjobs:[%d]\n", info2->cjobs));
3188                                 DEBUGADD(106,("averageppm:[%d]\n", info2->averageppm));
3189                                 DEBUGADD(106,("changeid:[%d]\n", info2->changeid));
3190                                 DEBUGADD(106,("c_setprinter:[%d]\n", info2->c_setprinter));
3191                                 DEBUGADD(106,("setuptime:[%d]\n", info2->setuptime));
3192
3193                                 DEBUGADD(106,("servername:[%s]\n", info2->servername));
3194                                 DEBUGADD(106,("printername:[%s]\n", info2->printername));
3195                                 DEBUGADD(106,("sharename:[%s]\n", info2->sharename));
3196                                 DEBUGADD(106,("portname:[%s]\n", info2->portname));
3197                                 DEBUGADD(106,("drivername:[%s]\n", info2->drivername));
3198                                 DEBUGADD(106,("comment:[%s]\n", info2->comment));
3199                                 DEBUGADD(106,("location:[%s]\n", info2->location));
3200                                 DEBUGADD(106,("sepfile:[%s]\n", info2->sepfile));
3201                                 DEBUGADD(106,("printprocessor:[%s]\n", info2->printprocessor));
3202                                 DEBUGADD(106,("datatype:[%s]\n", info2->datatype));
3203                                 DEBUGADD(106,("parameters:[%s]\n", info2->parameters));
3204                                 result=0;
3205                         }
3206                         break;
3207                 }
3208                 default:
3209                         DEBUGADD(106,("dump_a_printer: Level %u not implemented\n", (unsigned int)level ));
3210                         result=1;
3211                         break;
3212         }
3213
3214         return result;
3215 }
3216
3217 /****************************************************************************
3218  Get the parameters we can substitute in an NT print job.
3219 ****************************************************************************/
3220
3221 void get_printer_subst_params(int snum, fstring *printername, fstring *sharename, fstring *portname)
3222 {
3223         NT_PRINTER_INFO_LEVEL *printer = NULL;
3224
3225         **printername = **sharename = **portname = '\0';
3226
3227         if (!W_ERROR_IS_OK(get_a_printer(&printer, 2, lp_servicename(snum))))
3228                 return;
3229
3230         fstrcpy(*printername, printer->info_2->printername);
3231         fstrcpy(*sharename, printer->info_2->sharename);
3232         fstrcpy(*portname, printer->info_2->portname);
3233
3234         free_a_printer(&printer, 2);
3235 }
3236
3237 /****************************************************************************
3238  Update the changeid time.
3239  This is SO NASTY as some drivers need this to change, others need it
3240  static. This value will change every second, and I must hope that this
3241  is enough..... DON'T CHANGE THIS CODE WITHOUT A TEST MATRIX THE SIZE OF
3242  UTAH ! JRA.
3243 ****************************************************************************/
3244
3245 static uint32 rev_changeid(void)
3246 {
3247         struct timeval tv;
3248
3249         get_process_uptime(&tv);
3250
3251 #if 1   /* JERRY */
3252         /* Return changeid as msec since spooler restart */
3253         return tv.tv_sec * 1000 + tv.tv_usec / 1000;
3254 #else
3255         /*
3256          * This setting seems to work well but is too untested
3257          * to replace the above calculation.  Left in for experiementation
3258          * of the reader            --jerry (Tue Mar 12 09:15:05 CST 2002)
3259          */
3260         return tv.tv_sec * 10 + tv.tv_usec / 100000;
3261 #endif
3262 }
3263
3264 /*
3265  * The function below are the high level ones.
3266  * only those ones must be called from the spoolss code.
3267  * JFM.
3268  */
3269
3270 /****************************************************************************
3271  Modify a printer. This is called from SETPRINTERDATA/DELETEPRINTERDATA.
3272 ****************************************************************************/
3273
3274 WERROR mod_a_printer(NT_PRINTER_INFO_LEVEL printer, uint32 level)
3275 {
3276         WERROR result;
3277
3278         dump_a_printer(printer, level);
3279
3280         switch (level)
3281         {
3282                 case 2:
3283                 {
3284                         /*
3285                          * Update the changestamp.  Emperical tests show that the
3286                          * ChangeID is always updated,but c_setprinter is
3287                          *  global spooler variable (not per printer).
3288                          */
3289
3290                         /* ChangeID **must** be increasing over the lifetime
3291                            of client's spoolss service in order for the
3292                            client's cache to show updates */
3293
3294                         printer.info_2->changeid = rev_changeid();
3295
3296                         /*
3297                          * Because one day someone will ask:
3298                          * NT->NT       An admin connection to a remote
3299                          *              printer show changes imeediately in
3300                          *              the properities dialog
3301                          *
3302                          *              A non-admin connection will only show the
3303                          *              changes after viewing the properites page
3304                          *              2 times.  Seems to be related to a
3305                          *              race condition in the client between the spooler
3306                          *              updating the local cache and the Explorer.exe GUI
3307                          *              actually displaying the properties.
3308                          *
3309                          *              This is fixed in Win2k.  admin/non-admin
3310                          *              connections both display changes immediately.
3311                          *
3312                          * 14/12/01     --jerry
3313                          */
3314
3315                         result=update_a_printer_2(printer.info_2);
3316                         break;
3317                 }
3318                 default:
3319                         result=WERR_UNKNOWN_LEVEL;
3320                         break;
3321         }
3322
3323         return result;
3324 }
3325
3326 /****************************************************************************
3327  Initialize printer devmode & data with previously saved driver init values.
3328 ****************************************************************************/
3329
3330 static BOOL set_driver_init_2( NT_PRINTER_INFO_LEVEL_2 *info_ptr )
3331 {
3332         int                     len = 0;
3333         pstring                 key;
3334         TDB_DATA                kbuf, dbuf;
3335         NT_PRINTER_INFO_LEVEL_2 info;
3336
3337
3338         ZERO_STRUCT(info);
3339
3340         /*
3341          * Delete any printer data 'values' already set. When called for driver
3342          * replace, there will generally be some, but during an add printer, there
3343          * should not be any (if there are delete them).
3344          */
3345
3346         delete_all_printer_data( info_ptr, "" );
3347
3348         slprintf(key, sizeof(key)-1, "%s%s", DRIVER_INIT_PREFIX, info_ptr->drivername);
3349
3350         kbuf.dptr = key;
3351         kbuf.dsize = strlen(key)+1;
3352
3353         dbuf = tdb_fetch(tdb_drivers, kbuf);
3354         if (!dbuf.dptr) {
3355                 /*
3356                  * When changing to a driver that has no init info in the tdb, remove
3357                  * the previous drivers init info and leave the new on blank.
3358                  */
3359                 free_nt_devicemode(&info_ptr->devmode);
3360                 return False;
3361         }
3362
3363         /*
3364          * Get the saved DEVMODE..
3365          */
3366
3367         len += unpack_devicemode(&info.devmode,dbuf.dptr+len, dbuf.dsize-len);
3368
3369         /*
3370          * The saved DEVMODE contains the devicename from the printer used during
3371          * the initialization save. Change it to reflect the new printer.
3372          */
3373
3374         if ( info.devmode ) {
3375                 ZERO_STRUCT(info.devmode->devicename);
3376                 fstrcpy(info.devmode->devicename, info_ptr->printername);
3377         }
3378
3379         /*
3380          * NT/2k does not change out the entire DeviceMode of a printer
3381          * when changing the driver.  Only the driverextra, private, &
3382          * driverversion fields.   --jerry  (Thu Mar 14 08:58:43 CST 2002)
3383          *
3384          * Later examination revealed that Windows NT/2k does reset the
3385          * the printer's device mode, bit **only** when you change a
3386          * property of the device mode such as the page orientation.
3387          * --jerry
3388          */
3389
3390
3391         /* Bind the saved DEVMODE to the new the printer */
3392
3393         free_nt_devicemode(&info_ptr->devmode);
3394         info_ptr->devmode = info.devmode;
3395
3396         DEBUG(10,("set_driver_init_2: Set printer [%s] init %s DEVMODE for driver [%s]\n",
3397                 info_ptr->printername, info_ptr->devmode?"VALID":"NULL", info_ptr->drivername));
3398
3399         /* Add the printer data 'values' to the new printer */
3400
3401         len += unpack_values( &info_ptr->data, dbuf.dptr+len, dbuf.dsize-len );
3402
3403
3404         SAFE_FREE(dbuf.dptr);
3405
3406         return True;
3407 }
3408
3409 /****************************************************************************
3410  Initialize printer devmode & data with previously saved driver init values.
3411  When a printer is created using AddPrinter, the drivername bound to the
3412  printer is used to lookup previously saved driver initialization info, which
3413  is bound to the new printer.
3414 ****************************************************************************/
3415
3416 BOOL set_driver_init(NT_PRINTER_INFO_LEVEL *printer, uint32 level)
3417 {
3418         BOOL result = False;
3419
3420         switch (level)
3421         {
3422                 case 2:
3423                         result = set_driver_init_2(printer->info_2);
3424                         break;
3425
3426                 default:
3427                         DEBUG(0,("set_driver_init: Programmer's error!  Unknown driver_init level [%d]\n",
3428                                 level));
3429                         break;
3430         }
3431
3432         return result;
3433 }
3434
3435 /****************************************************************************
3436  Delete driver init data stored for a specified driver
3437 ****************************************************************************/
3438
3439 BOOL del_driver_init(char *drivername)
3440 {
3441         pstring key;
3442         TDB_DATA kbuf;
3443
3444         if (!drivername || !*drivername) {
3445                 DEBUG(3,("del_driver_init: No drivername specified!\n"));
3446                 return False;
3447         }
3448
3449         slprintf(key, sizeof(key)-1, "%s%s", DRIVER_INIT_PREFIX, drivername);
3450
3451         kbuf.dptr = key;
3452         kbuf.dsize = strlen(key)+1;
3453
3454         DEBUG(6,("del_driver_init: Removing driver init data for [%s]\n", drivername));
3455
3456         return (tdb_delete(tdb_drivers, kbuf) == 0);
3457 }
3458
3459 /****************************************************************************
3460  Pack up the DEVMODE and values for a printer into a 'driver init' entry
3461  in the tdb. Note: this is different from the driver entry and the printer
3462  entry. There should be a single driver init entry for each driver regardless
3463  of whether it was installed from NT or 2K. Technically, they should be
3464  different, but they work out to the same struct.
3465 ****************************************************************************/
3466
3467 static uint32 update_driver_init_2(NT_PRINTER_INFO_LEVEL_2 *info)
3468 {
3469         pstring key;
3470         char *buf;
3471         int buflen, len, ret;
3472         TDB_DATA kbuf, dbuf;
3473
3474         buf = NULL;
3475         buflen = 0;
3476
3477  again:
3478         len = 0;
3479         len += pack_devicemode(info->devmode, buf+len, buflen-len);
3480
3481         len += pack_values( &info->data, buf+len, buflen-len );
3482
3483         if (buflen != len) {
3484                 char *tb;
3485
3486                 tb = (char *)Realloc(buf, len);
3487                 if (!tb) {
3488                         DEBUG(0, ("update_driver_init_2: failed to enlarge buffer!\n"));
3489                         ret = -1;
3490                         goto done;
3491                 }
3492                 else buf = tb;
3493                 buflen = len;
3494                 goto again;
3495         }
3496
3497         slprintf(key, sizeof(key)-1, "%s%s", DRIVER_INIT_PREFIX, info->drivername);
3498
3499         kbuf.dptr = key;
3500         kbuf.dsize = strlen(key)+1;
3501         dbuf.dptr = buf;
3502         dbuf.dsize = len;
3503
3504         ret = tdb_store(tdb_drivers, kbuf, dbuf, TDB_REPLACE);
3505
3506 done:
3507         if (ret == -1)
3508                 DEBUG(8, ("update_driver_init_2: error updating printer init to tdb on disk\n"));
3509
3510         SAFE_FREE(buf);
3511
3512         DEBUG(10,("update_driver_init_2: Saved printer [%s] init DEVMODE & values for driver [%s]\n",
3513                  info->sharename, info->drivername));
3514
3515         return ret;
3516 }
3517
3518 /****************************************************************************
3519  Update (i.e. save) the driver init info (DEVMODE and values) for a printer
3520 ****************************************************************************/
3521
3522 uint32 update_driver_init(NT_PRINTER_INFO_LEVEL printer, uint32 level)
3523 {
3524         uint32 result;
3525
3526         dump_a_printer(printer, level);
3527
3528         switch (level)
3529         {
3530                 case 2:
3531                 {
3532                         result = update_driver_init_2(printer.info_2);
3533                         break;
3534                 }
3535                 default:
3536                         result = 1;
3537                         break;
3538         }
3539
3540         return result;
3541 }
3542
3543 /****************************************************************************
3544  Convert the printer data value, a REG_BINARY array, into an initialization
3545  DEVMODE. Note: the array must be parsed as if it was a DEVMODE in an rpc...
3546  got to keep the endians happy :).
3547 ****************************************************************************/
3548
3549 static BOOL convert_driver_init( TALLOC_CTX *ctx, NT_DEVICEMODE *nt_devmode, uint8 *data, uint32 data_len )
3550 {
3551         BOOL       result = False;
3552         prs_struct ps;
3553         DEVICEMODE devmode;
3554
3555         ZERO_STRUCT(devmode);
3556
3557         prs_init(&ps, 0, ctx, UNMARSHALL);
3558         ps.data_p      = (char *)data;
3559         ps.buffer_size = data_len;
3560
3561         if (spoolss_io_devmode("phantom DEVMODE", &ps, 0, &devmode))
3562                 result = convert_devicemode("", &devmode, &nt_devmode);
3563         else
3564                 DEBUG(10,("convert_driver_init: error parsing DEVMODE\n"));
3565
3566         return result;
3567 }
3568
3569 /****************************************************************************
3570  Set the DRIVER_INIT info in the tdb. Requires Win32 client code that:
3571
3572  1. Use the driver's config DLL to this UNC printername and:
3573     a. Call DrvPrintEvent with PRINTER_EVENT_INITIALIZE
3574     b. Call DrvConvertDevMode with CDM_DRIVER_DEFAULT to get default DEVMODE
3575  2. Call SetPrinterData with the 'magic' key and the DEVMODE as data.
3576
3577  The last step triggers saving the "driver initialization" information for
3578  this printer into the tdb. Later, new printers that use this driver will
3579  have this initialization information bound to them. This simulates the
3580  driver initialization, as if it had run on the Samba server (as it would
3581  have done on NT).
3582
3583  The Win32 client side code requirement sucks! But until we can run arbitrary
3584  Win32 printer driver code on any Unix that Samba runs on, we are stuck with it.
3585
3586  It would have been easier to use SetPrinter because all the UNMARSHALLING of
3587  the DEVMODE is done there, but 2K/XP clients do not set the DEVMODE... think
3588  about it and you will realize why.  JRR 010720
3589 ****************************************************************************/
3590
3591 static WERROR save_driver_init_2(NT_PRINTER_INFO_LEVEL *printer, uint8 *data, uint32 data_len )
3592 {
3593         WERROR        status       = WERR_OK;
3594         TALLOC_CTX    *ctx         = NULL;
3595         NT_DEVICEMODE *nt_devmode  = NULL;
3596         NT_DEVICEMODE *tmp_devmode = printer->info_2->devmode;
3597
3598         /*
3599          * When the DEVMODE is already set on the printer, don't try to unpack it.
3600          */
3601         DEBUG(8,("save_driver_init_2: Enter...\n"));
3602
3603         if ( !printer->info_2->devmode && data_len )
3604         {
3605                 /*
3606                  * Set devmode on printer info, so entire printer initialization can be
3607                  * saved to tdb.
3608                  */
3609
3610                 if ((ctx = talloc_init()) == NULL)
3611                         return WERR_NOMEM;
3612
3613                 if ((nt_devmode = (NT_DEVICEMODE*)malloc(sizeof(NT_DEVICEMODE))) == NULL) {
3614                         status = WERR_NOMEM;
3615                         goto done;
3616                 }
3617
3618                 ZERO_STRUCTP(nt_devmode);
3619
3620                 /*
3621                  * The DEVMODE is held in the 'data' component of the param in raw binary.
3622                  * Convert it to to a devmode structure
3623                  */
3624                 if ( !convert_driver_init( ctx, nt_devmode, data, data_len )) {
3625                         DEBUG(10,("save_driver_init_2: error converting DEVMODE\n"));
3626                         status = WERR_INVALID_PARAM;
3627                         goto done;
3628                 }
3629
3630                 printer->info_2->devmode = nt_devmode;
3631         }
3632
3633         /*
3634          * Pack up and add (or update) the DEVMODE and any current printer data to
3635          * a 'driver init' element in the tdb
3636          *
3637          */
3638
3639         if ( update_driver_init(*printer, 2) != 0 ) {
3640                 DEBUG(10,("save_driver_init_2: error updating DEVMODE\n"));
3641                 status = WERR_NOMEM;
3642                 goto done;
3643         }
3644
3645         /*
3646          * If driver initialization info was successfully saved, set the current
3647          * printer to match it. This allows initialization of the current printer
3648          * as well as the driver.
3649          */
3650         status = mod_a_printer(*printer, 2);
3651         if (!W_ERROR_IS_OK(status)) {
3652                 DEBUG(10,("save_driver_init_2: error setting DEVMODE on printer [%s]\n",
3653                                   printer->info_2->printername));
3654         }
3655
3656   done:
3657         talloc_destroy(ctx);
3658         free_nt_devicemode( &nt_devmode );
3659
3660         printer->info_2->devmode = tmp_devmode;
3661
3662         return status;
3663 }
3664
3665 /****************************************************************************
3666  Update the driver init info (DEVMODE and specifics) for a printer
3667 ****************************************************************************/
3668
3669 WERROR save_driver_init(NT_PRINTER_INFO_LEVEL *printer, uint32 level, uint8 *data, uint32 data_len)
3670 {
3671         WERROR status = WERR_OK;
3672
3673         switch (level)
3674         {
3675                 case 2:
3676                 {
3677                         status = save_driver_init_2( printer, data, data_len );
3678                         break;
3679                 }
3680                 default:
3681                         status = WERR_UNKNOWN_LEVEL;
3682                         break;
3683         }
3684
3685         return status;
3686 }
3687
3688 /****************************************************************************
3689  Get a NT_PRINTER_INFO_LEVEL struct. It returns malloced memory.
3690 ****************************************************************************/
3691
3692 WERROR get_a_printer(NT_PRINTER_INFO_LEVEL **pp_printer, uint32 level, fstring sharename)
3693 {
3694         WERROR result;
3695         NT_PRINTER_INFO_LEVEL *printer = NULL;
3696
3697         *pp_printer = NULL;
3698
3699         DEBUG(10,("get_a_printer: [%s] level %u\n", sharename, (unsigned int)level));
3700
3701         switch (level)
3702         {
3703                 case 2:
3704                 {
3705                         if ((printer = (NT_PRINTER_INFO_LEVEL *)malloc(sizeof(NT_PRINTER_INFO_LEVEL))) == NULL) {
3706                                 DEBUG(0,("get_a_printer: malloc fail.\n"));
3707                                 return WERR_NOMEM;
3708                         }
3709                         ZERO_STRUCTP(printer);
3710                         result=get_a_printer_2(&printer->info_2, sharename);
3711                         if (W_ERROR_IS_OK(result)) {
3712                                 dump_a_printer(*printer, level);
3713                                 *pp_printer = printer;
3714                         } else {
3715                                 SAFE_FREE(printer);
3716                         }
3717                         break;
3718                 }
3719                 default:
3720                         result=WERR_UNKNOWN_LEVEL;
3721                         break;
3722         }
3723
3724         DEBUG(10,("get_a_printer: [%s] level %u returning %s\n", sharename, (unsigned int)level, dos_errstr(result)));
3725
3726         return result;
3727 }
3728
3729 /****************************************************************************
3730  Deletes a NT_PRINTER_INFO_LEVEL struct.
3731 ****************************************************************************/
3732
3733 uint32 free_a_printer(NT_PRINTER_INFO_LEVEL **pp_printer, uint32 level)
3734 {
3735         uint32 result;
3736         NT_PRINTER_INFO_LEVEL *printer = *pp_printer;
3737
3738         DEBUG(104,("freeing a printer at level [%d]\n", level));
3739
3740         if (printer == NULL)
3741                 return 0;
3742
3743         switch (level)
3744         {
3745                 case 2:
3746                 {
3747                         if (printer->info_2 != NULL)
3748                         {
3749                                 free_nt_printer_info_level_2(&printer->info_2);
3750                                 result=0;
3751                         }
3752                         else
3753                         {
3754                                 result=4;
3755                         }
3756                         break;
3757                 }
3758                 default:
3759                         result=1;
3760                         break;
3761         }
3762
3763         SAFE_FREE(*pp_printer);
3764         return result;
3765 }
3766
3767 /****************************************************************************
3768 ****************************************************************************/
3769 uint32 add_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
3770 {
3771         uint32 result;
3772         DEBUG(104,("adding a printer at level [%d]\n", level));
3773         dump_a_printer_driver(driver, level);
3774
3775         switch (level)
3776         {
3777                 case 3:
3778                 {
3779                         result=add_a_printer_driver_3(driver.info_3);
3780                         break;
3781                 }
3782
3783                 case 6:
3784                 {
3785                         result=add_a_printer_driver_6(driver.info_6);
3786                         break;
3787                 }
3788                 default:
3789                         result=1;
3790                         break;
3791         }
3792
3793         return result;
3794 }
3795 /****************************************************************************
3796 ****************************************************************************/
3797 WERROR get_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL *driver, uint32 level,
3798                             fstring drivername, fstring architecture, uint32 version)
3799 {
3800         WERROR result;
3801
3802         switch (level)
3803         {
3804                 case 3:
3805                         /* Sometime we just want any version of the driver */
3806
3807                         if ( version == DRIVER_ANY_VERSION ) {
3808                                 /* look for Win2k first and then for NT4 */
3809                                 result = get_a_printer_driver_3(&driver->info_3, drivername,
3810                                                 architecture, 3);
3811
3812                                 if ( !W_ERROR_IS_OK(result) ) {
3813                                         result = get_a_printer_driver_3( &driver->info_3,
3814                                                         drivername, architecture, 2 );
3815                                 }
3816                         }
3817                         else {
3818                                 result = get_a_printer_driver_3(&driver->info_3, drivername,
3819                                         architecture, version);
3820                         }
3821                         break;
3822
3823                 default:
3824                         result=W_ERROR(1);
3825                         break;
3826         }
3827
3828         if (W_ERROR_IS_OK(result))
3829                 dump_a_printer_driver(*driver, level);
3830
3831         return result;
3832 }
3833
3834 /****************************************************************************
3835 ****************************************************************************/
3836 uint32 free_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
3837 {
3838         uint32 result;
3839
3840         switch (level)
3841         {
3842                 case 3:
3843                 {
3844                         NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3;
3845                         if (driver.info_3 != NULL)
3846                         {
3847                                 info3=driver.info_3;
3848                                 SAFE_FREE(info3->dependentfiles);
3849                                 ZERO_STRUCTP(info3);
3850                                 SAFE_FREE(info3);
3851                                 result=0;
3852                         }
3853                         else
3854                         {
3855                                 result=4;
3856                         }
3857                         break;
3858                 }
3859                 case 6:
3860                 {
3861                         NT_PRINTER_DRIVER_INFO_LEVEL_6 *info6;
3862                         if (driver.info_6 != NULL)
3863                         {
3864                                 info6=driver.info_6;
3865                                 SAFE_FREE(info6->dependentfiles);
3866                                 SAFE_FREE(info6->previousnames);
3867                                 ZERO_STRUCTP(info6);
3868                                 SAFE_FREE(info6);
3869                                 result=0;
3870                         }
3871                         else
3872                         {
3873                                 result=4;
3874                         }
3875                         break;
3876                 }
3877                 default:
3878                         result=1;
3879                         break;
3880         }
3881         return result;
3882 }
3883
3884
3885 /****************************************************************************
3886   Determine whether or not a particular driver is currently assigned
3887   to a printer
3888 ****************************************************************************/
3889
3890 BOOL printer_driver_in_use ( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info_3 )
3891 {
3892         int snum;
3893         int n_services = lp_numservices();
3894         NT_PRINTER_INFO_LEVEL *printer = NULL;
3895
3896         if ( !info_3 )
3897                 return False;
3898
3899         DEBUG(5,("printer_driver_in_use: Beginning search through ntprinters.tdb...\n"));
3900
3901         /* loop through the printers.tdb and check for the drivername */
3902
3903         for (snum=0; snum<n_services; snum++)
3904         {
3905                 if ( !(lp_snum_ok(snum) && lp_print_ok(snum) ) )
3906                         continue;
3907
3908                 if ( !W_ERROR_IS_OK(get_a_printer(&printer, 2, lp_servicename(snum))) )
3909                         continue;
3910
3911                 if ( !StrCaseCmp(info_3->name, printer->info_2->drivername) ) {
3912                         free_a_printer( &printer, 2 );
3913                         return True;
3914                 }
3915
3916                 free_a_printer( &printer, 2 );
3917         }
3918
3919         DEBUG(5,("printer_driver_in_use: Completed search through ntprinters.tdb...\n"));
3920
3921         /* report that the driver is not in use by default */
3922
3923         return False;
3924 }
3925
3926
3927 /**********************************************************************
3928  Check to see if a ogiven file is in use by *info
3929  *********************************************************************/
3930
3931 static BOOL drv_file_in_use( char* file, NT_PRINTER_DRIVER_INFO_LEVEL_3 *info )
3932 {
3933         int i = 0;
3934
3935         if ( !info )
3936                 return False;
3937
3938         if ( strequal(file, info->driverpath) )
3939                 return True;
3940
3941         if ( strequal(file, info->datafile) )
3942                 return True;
3943
3944         if ( strequal(file, info->configfile) )
3945                 return True;
3946
3947         if ( strequal(file, info->helpfile) )
3948                 return True;
3949
3950         /* see of there are any dependent files to examine */
3951
3952         if ( !info->dependentfiles )
3953                 return False;
3954
3955         while ( *info->dependentfiles[i] )
3956         {
3957                 if ( strequal(file, info->dependentfiles[i]) )
3958                         return True;
3959
3960                 i++;
3961         }
3962
3963         return False;
3964
3965 }
3966
3967 /**********************************************************************
3968  Utility function to remove the dependent file pointed to by the
3969  input parameter from the list
3970  *********************************************************************/
3971
3972 static void trim_dependent_file( fstring files[], int idx )
3973 {
3974
3975         /* bump everything down a slot */
3976
3977         while( *files[idx+1] )
3978         {
3979                 fstrcpy( files[idx], files[idx+1] );
3980                 idx++;
3981         }
3982
3983         *files[idx] = '\0';
3984
3985         return;
3986 }
3987
3988 /**********************************************************************
3989  Check if any of the files used by src are also used by drv
3990  *********************************************************************/
3991
3992 static BOOL trim_overlap_drv_files( NT_PRINTER_DRIVER_INFO_LEVEL_3 *src,
3993                                        NT_PRINTER_DRIVER_INFO_LEVEL_3 *drv )
3994 {
3995         BOOL    in_use = False;
3996         int     i = 0;
3997
3998         if ( !src || !drv )
3999                 return False;
4000
4001         /* check each file.  Remove it from the src structure if it overlaps */
4002
4003         if ( drv_file_in_use(src->driverpath, drv) ) {
4004                 in_use = True;
4005                 DEBUG(10,("Removing driverfile [%s] from list\n", src->driverpath));
4006                 fstrcpy( src->driverpath, "" );
4007         }
4008
4009         if ( drv_file_in_use(src->datafile, drv) ) {
4010                 in_use = True;
4011                 DEBUG(10,("Removing datafile [%s] from list\n", src->datafile));
4012                 fstrcpy( src->datafile, "" );
4013         }
4014
4015         if ( drv_file_in_use(src->configfile, drv) ) {
4016                 in_use = True;
4017                 DEBUG(10,("Removing configfile [%s] from list\n", src->configfile));
4018                 fstrcpy( src->configfile, "" );
4019         }
4020
4021         if ( drv_file_in_use(src->helpfile, drv) ) {
4022                 in_use = True;
4023                 DEBUG(10,("Removing helpfile [%s] from list\n", src->helpfile));
4024                 fstrcpy( src->helpfile, "" );
4025         }
4026
4027         /* are there any dependentfiles to examine? */
4028
4029         if ( !src->dependentfiles )
4030                 return in_use;
4031
4032         while ( *src->dependentfiles[i] )
4033         {
4034                 if ( drv_file_in_use(src->dependentfiles[i], drv) ) {
4035                         in_use = True;
4036                         DEBUG(10,("Removing [%s] from dependent file list\n", src->dependentfiles[i]));
4037                         trim_dependent_file( src->dependentfiles, i );
4038                 }
4039                 else
4040                         i++;
4041         }
4042
4043         return in_use;
4044 }
4045
4046 /****************************************************************************
4047   Determine whether or not a particular driver files are currently being
4048   used by any other driver.
4049
4050   Return value is True if any files were in use by other drivers
4051   and False otherwise.
4052
4053   Upon return, *info has been modified to only contain the driver files
4054   which are not in use
4055 ****************************************************************************/
4056
4057 BOOL printer_driver_files_in_use ( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info )
4058 {
4059         int                             i;
4060         int                             ndrivers;
4061         uint32                          version;
4062         fstring                         *list = NULL;
4063         NT_PRINTER_DRIVER_INFO_LEVEL    driver;
4064
4065         if ( !info )
4066                 return False;
4067
4068         version = info->cversion;
4069
4070         /* loop over all driver versions */
4071
4072         DEBUG(5,("printer_driver_files_in_use: Beginning search through ntdrivers.tdb...\n"));
4073
4074         /* get the list of drivers */
4075
4076         list = NULL;
4077         ndrivers = get_ntdrivers(&list, info->environment, version);
4078
4079         DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
4080                 ndrivers, info->environment, version));
4081
4082         /* check each driver for overlap in files */
4083
4084         for (i=0; i<ndrivers; i++)
4085         {
4086                 DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
4087
4088                 ZERO_STRUCT(driver);
4089
4090                 if ( !W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, list[i],
4091                         info->environment, version)) )
4092                 {
4093                         SAFE_FREE(list);
4094                         return True;
4095                 }
4096
4097                 /* check if d2 uses any files from d1 */
4098                 /* only if this is a different driver than the one being deleted */
4099
4100                 if ( !strequal(info->name, driver.info_3->name) )
4101                 {
4102                         if ( trim_overlap_drv_files(info, driver.info_3) ) {
4103                                 free_a_printer_driver(driver, 3);
4104                                 SAFE_FREE( list );
4105                                 return True;
4106                         }
4107                 }
4108
4109                 free_a_printer_driver(driver, 3);
4110         }
4111
4112         SAFE_FREE(list);
4113
4114         DEBUG(5,("printer_driver_files_in_use: Completed search through ntdrivers.tdb...\n"));
4115
4116         driver.info_3 = info;
4117
4118         if ( DEBUGLEVEL >= 20 )
4119                 dump_a_printer_driver( driver, 3 );
4120
4121         return False;
4122 }
4123
4124 /****************************************************************************
4125   Actually delete the driver files.  Make sure that
4126   printer_driver_files_in_use() return False before calling
4127   this.
4128 ****************************************************************************/
4129
4130 static BOOL delete_driver_files( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info_3, struct current_user *user )
4131 {
4132         int i = 0;
4133         char *s;
4134         connection_struct *conn;
4135         DATA_BLOB null_pw;
4136         NTSTATUS nt_status;
4137
4138         if ( !info_3 )
4139                 return False;
4140
4141         DEBUG(6,("delete_driver_files: deleting driver [%s] - version [%d]\n", info_3->name, info_3->cversion));
4142
4143         /*
4144          * Connect to the print$ share under the same account as the
4145          * user connected to the rpc pipe. Note we must be root to
4146          * do this.
4147          */
4148
4149         become_root();
4150         null_pw = data_blob( NULL, 0 );
4151         conn = make_connection_with_chdir( "print$", null_pw, "A:", user->vuid, &nt_status );
4152         unbecome_root();
4153
4154         if ( !conn ) {
4155                 DEBUG(0,("delete_driver_files: Unable to connect\n"));
4156                 return False;
4157         }
4158
4159         /* Save who we are - we are temporarily becoming the connection user. */
4160
4161         if ( !become_user(conn, conn->vuid) ) {
4162                 DEBUG(0,("delete_driver_files: Can't become user!\n"));
4163                 return False;
4164         }
4165
4166         /* now delete the files; must strip the '\print$' string from
4167            fron of path                                                */
4168
4169         if ( *info_3->driverpath ) {
4170                 if ( (s = strchr( &info_3->driverpath[1], '\\' )) != NULL ) {
4171                         DEBUG(10,("deleting driverfile [%s]\n", s));
4172                         unlink_internals(conn, 0, s);
4173                 }
4174         }
4175
4176         if ( *info_3->configfile ) {
4177                 if ( (s = strchr( &info_3->configfile[1], '\\' )) != NULL ) {
4178                         DEBUG(10,("deleting configfile [%s]\n", s));
4179                         unlink_internals(conn, 0, s);
4180                 }
4181         }
4182
4183         if ( *info_3->datafile ) {
4184                 if ( (s = strchr( &info_3->datafile[1], '\\' )) != NULL ) {
4185                         DEBUG(10,("deleting datafile [%s]\n", s));
4186                         unlink_internals(conn, 0, s);
4187                 }
4188         }
4189
4190         if ( *info_3->helpfile ) {
4191                 if ( (s = strchr( &info_3->helpfile[1], '\\' )) != NULL ) {
4192                         DEBUG(10,("deleting helpfile [%s]\n", s));
4193                         unlink_internals(conn, 0, s);
4194                 }
4195         }
4196
4197         /* check if we are done removing files */
4198
4199         if ( info_3->dependentfiles )
4200         {
4201                 while ( *info_3->dependentfiles[i] ) {
4202                         char *file;
4203
4204                         /* bypass the "\print$" portion of the path */
4205
4206                         if ( (file = strchr( info_3->dependentfiles[i]+1, '\\' )) != NULL )
4207                         {
4208                                 DEBUG(10,("deleting dependent file [%s]\n", file));
4209                                 unlink_internals(conn, 0, file );
4210                         }
4211
4212                         i++;
4213                 }
4214         }
4215
4216         unbecome_user();
4217
4218         return True;
4219 }
4220
4221 /****************************************************************************
4222  Remove a printer driver from the TDB.  This assumes that the the driver was
4223  previously looked up.
4224  ***************************************************************************/
4225
4226 WERROR delete_printer_driver( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info_3, struct current_user *user,
4227                               uint32 version, BOOL delete_files )
4228 {
4229         pstring         key;
4230         fstring         arch;
4231         TDB_DATA        kbuf, dbuf;
4232         NT_PRINTER_DRIVER_INFO_LEVEL    ctr;
4233
4234         /* delete the tdb data first */
4235
4236         get_short_archi(arch, info_3->environment);
4237         slprintf(key, sizeof(key)-1, "%s%s/%d/%s", DRIVERS_PREFIX,
4238                 arch, version, info_3->name);
4239
4240         DEBUG(5,("delete_printer_driver: key = [%s] delete_files = %s\n",
4241                 key, delete_files ? "TRUE" : "FALSE" ));
4242
4243         ctr.info_3 = info_3;
4244         dump_a_printer_driver( ctr, 3 );
4245
4246         kbuf.dptr=key;
4247         kbuf.dsize=strlen(key)+1;
4248
4249         /* check if the driver actually exists for this environment */
4250
4251         dbuf = tdb_fetch( tdb_drivers, kbuf );
4252         if ( !dbuf.dptr ) {
4253                 DEBUG(8,("delete_printer_driver: Driver unknown [%s]\n", key));
4254                 return WERR_UNKNOWN_PRINTER_DRIVER;
4255         }
4256
4257         SAFE_FREE( dbuf.dptr );
4258
4259         /* ok... the driver exists so the delete should return success */
4260
4261         if (tdb_delete(tdb_drivers, kbuf) == -1) {
4262                 DEBUG (0,("delete_printer_driver: fail to delete %s!\n", key));
4263                 return WERR_ACCESS_DENIED;
4264         }
4265
4266         /*
4267          * now delete any associated files if delete_files == True
4268          * even if this part failes, we return succes because the
4269          * driver doesn not exist any more
4270          */
4271
4272         if ( delete_files )
4273                 delete_driver_files( info_3, user );
4274
4275
4276         DEBUG(5,("delete_printer_driver: driver delete successful [%s]\n", key));
4277
4278         return WERR_OK;
4279         }
4280
4281 /****************************************************************************
4282  Store a security desc for a printer.
4283 ****************************************************************************/
4284
4285 WERROR nt_printing_setsec(const char *printername, SEC_DESC_BUF *secdesc_ctr)
4286 {
4287         SEC_DESC_BUF *new_secdesc_ctr = NULL;
4288         SEC_DESC_BUF *old_secdesc_ctr = NULL;
4289         prs_struct ps;
4290         TALLOC_CTX *mem_ctx = NULL;
4291         fstring key;
4292         WERROR status;
4293
4294         mem_ctx = talloc_init();
4295         if (mem_ctx == NULL)
4296                 return WERR_NOMEM;
4297
4298         /* The old owner and group sids of the security descriptor are not
4299            present when new ACEs are added or removed by changing printer
4300            permissions through NT.  If they are NULL in the new security
4301            descriptor then copy them over from the old one. */
4302
4303         if (!secdesc_ctr->sec->owner_sid || !secdesc_ctr->sec->grp_sid) {
4304                 DOM_SID *owner_sid, *group_sid;
4305                 SEC_ACL *dacl, *sacl;
4306                 SEC_DESC *psd = NULL;
4307                 size_t size;
4308
4309                 nt_printing_getsec(mem_ctx, printername, &old_secdesc_ctr);
4310
4311                 /* Pick out correct owner and group sids */
4312
4313                 owner_sid = secdesc_ctr->sec->owner_sid ?
4314                         secdesc_ctr->sec->owner_sid :
4315                         old_secdesc_ctr->sec->owner_sid;
4316
4317                 group_sid = secdesc_ctr->sec->grp_sid ?
4318                         secdesc_ctr->sec->grp_sid :
4319                         old_secdesc_ctr->sec->grp_sid;
4320
4321                 dacl = secdesc_ctr->sec->dacl ?
4322                         secdesc_ctr->sec->dacl :
4323                         old_secdesc_ctr->sec->dacl;
4324
4325                 sacl = secdesc_ctr->sec->sacl ?
4326                         secdesc_ctr->sec->sacl :
4327                         old_secdesc_ctr->sec->sacl;
4328
4329                 /* Make a deep copy of the security descriptor */
4330
4331                 psd = make_sec_desc(mem_ctx, secdesc_ctr->sec->revision,
4332                                     owner_sid, group_sid,
4333                                     sacl,
4334                                     dacl,
4335                                     &size);
4336
4337                 new_secdesc_ctr = make_sec_desc_buf(mem_ctx, size, psd);
4338         }
4339
4340         if (!new_secdesc_ctr) {
4341                 new_secdesc_ctr = secdesc_ctr;
4342         }
4343
4344         /* Store the security descriptor in a tdb */
4345
4346         prs_init(&ps, (uint32)sec_desc_size(new_secdesc_ctr->sec) +
4347                  sizeof(SEC_DESC_BUF), mem_ctx, MARSHALL);
4348
4349         if (!sec_io_desc_buf("nt_printing_setsec", &new_secdesc_ctr,
4350                              &ps, 1)) {
4351                 status = WERR_BADFUNC;
4352                 goto out;
4353         }
4354
4355         slprintf(key, sizeof(key)-1, "SECDESC/%s", printername);
4356
4357         if (tdb_prs_store(tdb_printers, key, &ps)==0) {
4358                 status = WERR_OK;
4359         } else {
4360                 DEBUG(1,("Failed to store secdesc for %s\n", printername));
4361                 status = WERR_BADFUNC;
4362         }
4363
4364         /* Free malloc'ed memory */
4365
4366  out:
4367
4368         prs_mem_free(&ps);
4369         if (mem_ctx)
4370                 talloc_destroy(mem_ctx);
4371         return status;
4372 }
4373
4374 /****************************************************************************
4375  Construct a default security descriptor buffer for a printer.
4376 ****************************************************************************/
4377
4378 static SEC_DESC_BUF *construct_default_printer_sdb(TALLOC_CTX *ctx)
4379 {
4380         SEC_ACE ace[3];
4381         SEC_ACCESS sa;
4382         SEC_ACL *psa = NULL;
4383         SEC_DESC_BUF *sdb = NULL;
4384         SEC_DESC *psd = NULL;
4385         DOM_SID owner_sid;
4386         size_t sd_size;
4387
4388         /* Create an ACE where Everyone is allowed to print */
4389
4390         init_sec_access(&sa, PRINTER_ACE_PRINT);
4391         init_sec_ace(&ace[0], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED,
4392                      sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
4393
4394         /* Make the security descriptor owned by the Administrators group
4395            on the PDC of the domain. */
4396
4397         if (secrets_fetch_domain_sid(lp_workgroup(), &owner_sid)) {
4398                 sid_append_rid(&owner_sid, DOMAIN_USER_RID_ADMIN);
4399         } else {
4400
4401                 /* Backup plan - make printer owned by admins.
4402                    This should emulate a lanman printer as security
4403                    settings can't be changed. */
4404
4405                 sid_copy(&owner_sid, get_global_sam_sid());
4406                 sid_append_rid(&owner_sid, DOMAIN_USER_RID_ADMIN);
4407         }
4408
4409         init_sec_access(&sa, PRINTER_ACE_FULL_CONTROL);
4410         init_sec_ace(&ace[1], &owner_sid, SEC_ACE_TYPE_ACCESS_ALLOWED,
4411                      sa, SEC_ACE_FLAG_OBJECT_INHERIT |
4412                      SEC_ACE_FLAG_INHERIT_ONLY);
4413
4414         init_sec_access(&sa, PRINTER_ACE_FULL_CONTROL);
4415         init_sec_ace(&ace[2], &owner_sid, SEC_ACE_TYPE_ACCESS_ALLOWED,
4416                      sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
4417
4418         /* The ACL revision number in rpc_secdesc.h differs from the one
4419            created by NT when setting ACE entries in printer
4420            descriptors.  NT4 complains about the property being edited by a
4421            NT5 machine. */
4422
4423         if ((psa = make_sec_acl(ctx, NT4_ACL_REVISION, 3, ace)) != NULL) {
4424                 psd = make_sec_desc(ctx, SEC_DESC_REVISION,
4425                                     &owner_sid, NULL,
4426                                     NULL, psa, &sd_size);
4427         }
4428
4429         if (!psd) {
4430                 DEBUG(0,("construct_default_printer_sd: Failed to make SEC_DESC.\n"));
4431                 return NULL;
4432         }
4433
4434         sdb = make_sec_desc_buf(ctx, sd_size, psd);
4435
4436         DEBUG(4,("construct_default_printer_sdb: size = %u.\n",
4437                  (unsigned int)sd_size));
4438
4439         return sdb;
4440 }
4441
4442 /****************************************************************************
4443  Get a security desc for a printer.
4444 ****************************************************************************/
4445
4446 BOOL nt_printing_getsec(TALLOC_CTX *ctx, const char *printername, SEC_DESC_BUF **secdesc_ctr)
4447 {
4448         prs_struct ps;
4449         fstring key;
4450         char *temp;
4451
4452         if (strlen(printername) > 2 && (temp = strchr(printername + 2, '\\')))
4453                 printername = temp + 1;
4454
4455         /* Fetch security descriptor from tdb */
4456
4457         slprintf(key, sizeof(key)-1, "SECDESC/%s", printername);
4458
4459         if (tdb_prs_fetch(tdb_printers, key, &ps, ctx)!=0 ||
4460             !sec_io_desc_buf("nt_printing_getsec", secdesc_ctr, &ps, 1)) {
4461
4462                 DEBUG(4,("using default secdesc for %s\n", printername));
4463
4464                 if (!(*secdesc_ctr = construct_default_printer_sdb(ctx))) {
4465                         return False;
4466                 }
4467
4468                 /* Save default security descriptor for later */
4469
4470                 prs_init(&ps, (uint32)sec_desc_size((*secdesc_ctr)->sec) +
4471                                 sizeof(SEC_DESC_BUF), ctx, MARSHALL);
4472
4473                 if (sec_io_desc_buf("nt_printing_getsec", secdesc_ctr, &ps, 1))
4474                         tdb_prs_store(tdb_printers, key, &ps);
4475
4476                 prs_mem_free(&ps);
4477
4478                 return True;
4479         }
4480
4481         /* If security descriptor is owned by S-1-1-0 and winbindd is up,
4482            this security descriptor has been created when winbindd was
4483            down.  Take ownership of security descriptor. */
4484
4485         if (sid_equal((*secdesc_ctr)->sec->owner_sid, &global_sid_World)) {
4486                 DOM_SID owner_sid;
4487
4488                 /* Change sd owner to workgroup administrator */
4489
4490                 if (secrets_fetch_domain_sid(lp_workgroup(), &owner_sid)) {
4491                         SEC_DESC_BUF *new_secdesc_ctr = NULL;
4492                         SEC_DESC *psd = NULL;
4493                         size_t size;
4494
4495                         /* Create new sd */
4496
4497                         sid_append_rid(&owner_sid, DOMAIN_USER_RID_ADMIN);
4498
4499                         psd = make_sec_desc(ctx, (*secdesc_ctr)->sec->revision,
4500                                             &owner_sid,
4501                                             (*secdesc_ctr)->sec->grp_sid,
4502                                             (*secdesc_ctr)->sec->sacl,
4503                                             (*secdesc_ctr)->sec->dacl,
4504                                             &size);
4505
4506                         new_secdesc_ctr = make_sec_desc_buf(ctx, size, psd);
4507
4508                         /* Swap with other one */
4509
4510                         *secdesc_ctr = new_secdesc_ctr;
4511
4512                         /* Set it */
4513
4514                         nt_printing_setsec(printername, *secdesc_ctr);
4515                 }
4516         }
4517
4518         if (DEBUGLEVEL >= 10) {
4519                 SEC_ACL *the_acl = (*secdesc_ctr)->sec->dacl;
4520                 int i;
4521
4522                 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
4523                            printername, the_acl->num_aces));
4524
4525                 for (i = 0; i < the_acl->num_aces; i++) {
4526                         fstring sid_str;
4527
4528                         sid_to_string(sid_str, &the_acl->ace[i].trustee);
4529
4530                         DEBUG(10, ("%s %d %d 0x%08x\n", sid_str,
4531                                    the_acl->ace[i].type, the_acl->ace[i].flags,
4532                                    the_acl->ace[i].info.mask));
4533                 }
4534         }
4535
4536         prs_mem_free(&ps);
4537         return True;
4538 }
4539
4540 /* error code:
4541         0: everything OK
4542         1: level not implemented
4543         2: file doesn't exist
4544         3: can't allocate memory
4545         4: can't free memory
4546         5: non existant struct
4547 */
4548
4549 /*
4550         A printer and a printer driver are 2 different things.
4551         NT manages them separatelly, Samba does the same.
4552         Why ? Simply because it's easier and it makes sense !
4553
4554         Now explanation: You have 3 printers behind your samba server,
4555         2 of them are the same make and model (laser A and B). But laser B
4556         has an 3000 sheet feeder and laser A doesn't such an option.
4557         Your third printer is an old dot-matrix model for the accounting :-).
4558
4559         If the /usr/local/samba/lib directory (default dir), you will have
4560         5 files to describe all of this.
4561
4562         3 files for the printers (1 by printer):
4563                 NTprinter_laser A
4564                 NTprinter_laser B
4565                 NTprinter_accounting
4566         2 files for the drivers (1 for the laser and 1 for the dot matrix)
4567                 NTdriver_printer model X
4568                 NTdriver_printer model Y
4569
4570 jfm: I should use this comment for the text file to explain
4571         same thing for the forms BTW.
4572         Je devrais mettre mes commentaires en francais, ca serait mieux :-)
4573
4574 */
4575
4576 /* Convert generic access rights to printer object specific access rights.
4577    It turns out that NT4 security descriptors use generic access rights and
4578    NT5 the object specific ones. */
4579
4580 void map_printer_permissions(SEC_DESC *sd)
4581 {
4582         int i;
4583
4584         for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) {
4585                 se_map_generic(&sd->dacl->ace[i].info.mask,
4586                                &printer_generic_mapping);
4587         }
4588 }
4589
4590 /****************************************************************************
4591  Check a user has permissions to perform the given operation.  We use the
4592  permission constants defined in include/rpc_spoolss.h to check the various
4593  actions we perform when checking printer access.
4594
4595    PRINTER_ACCESS_ADMINISTER:
4596        print_queue_pause, print_queue_resume, update_printer_sec,
4597        update_printer, spoolss_addprinterex_level_2,
4598        _spoolss_setprinterdata
4599
4600    PRINTER_ACCESS_USE:
4601        print_job_start
4602
4603    JOB_ACCESS_ADMINISTER:
4604        print_job_delete, print_job_pause, print_job_resume,
4605        print_queue_purge
4606
4607  ****************************************************************************/
4608 BOOL print_access_check(struct current_user *user, int snum, int access_type)
4609 {
4610         SEC_DESC_BUF *secdesc = NULL;
4611         uint32 access_granted;
4612         NTSTATUS status;
4613         BOOL result;
4614         const char *pname;
4615         TALLOC_CTX *mem_ctx = NULL;
4616         extern struct current_user current_user;
4617
4618         /* If user is NULL then use the current_user structure */
4619
4620         if (!user)
4621                 user = &current_user;
4622
4623         /* Always allow root or printer admins to do anything */
4624
4625         if (user->uid == 0 ||
4626             user_in_list(uidtoname(user->uid), lp_printer_admin(snum))) {
4627                 return True;
4628         }
4629
4630         /* Get printer name */
4631
4632         pname = PRINTERNAME(snum);
4633
4634         if (!pname || !*pname) {
4635                 errno = EACCES;
4636                 return False;
4637         }
4638
4639         /* Get printer security descriptor */
4640
4641         if(!(mem_ctx = talloc_init())) {
4642                 errno = ENOMEM;
4643                 return False;
4644         }
4645
4646         nt_printing_getsec(mem_ctx, pname, &secdesc);
4647
4648         if (access_type == JOB_ACCESS_ADMINISTER) {
4649                 SEC_DESC_BUF *parent_secdesc = secdesc;
4650
4651                 /* Create a child security descriptor to check permissions
4652                    against.  This is because print jobs are child objects
4653                    objects of a printer. */
4654
4655                 secdesc = se_create_child_secdesc(mem_ctx, parent_secdesc->sec, False);
4656
4657                 /* Now this is the bit that really confuses me.  The access
4658                    type needs to be changed from JOB_ACCESS_ADMINISTER to
4659                    PRINTER_ACCESS_ADMINISTER for this to work.  Something
4660                    to do with the child (job) object becoming like a
4661                    printer??  -tpot */
4662
4663                 access_type = PRINTER_ACCESS_ADMINISTER;
4664         }
4665
4666         /* Check access */
4667
4668         map_printer_permissions(secdesc->sec);
4669
4670         result = se_access_check(secdesc->sec, user->nt_user_token, access_type,
4671                                  &access_granted, &status);
4672
4673         DEBUG(4, ("access check was %s\n", result ? "SUCCESS" : "FAILURE"));
4674
4675         talloc_destroy(mem_ctx);
4676
4677         if (!result)
4678                 errno = EACCES;
4679
4680         return result;
4681 }
4682
4683 /****************************************************************************
4684  Check the time parameters allow a print operation.
4685 *****************************************************************************/
4686
4687 BOOL print_time_access_check(int snum)
4688 {
4689         NT_PRINTER_INFO_LEVEL *printer = NULL;
4690         BOOL ok = False;
4691         time_t now = time(NULL);
4692         struct tm *t;
4693         uint32 mins;
4694
4695         if (!W_ERROR_IS_OK(get_a_printer(&printer, 2, lp_servicename(snum))))
4696                 return False;
4697
4698         if (printer->info_2->starttime == 0 && printer->info_2->untiltime == 0)
4699                 ok = True;
4700
4701         t = gmtime(&now);
4702         mins = (uint32)t->tm_hour*60 + (uint32)t->tm_min;
4703
4704         if (mins >= printer->info_2->starttime && mins <= printer->info_2->untiltime)
4705                 ok = True;
4706
4707         free_a_printer(&printer, 2);
4708
4709         if (!ok)
4710                 errno = EACCES;
4711
4712         return ok;
4713 }
4714