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