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