244b3aee03e9f34cfc2e8283539d1b8cc8c1ef1d
[samba.git] / 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 struct table_node {
208         const char      *long_archi;
209         const char      *short_archi;
210         int     version;
211 };
212  
213 #define SPL_ARCH_WIN40          "WIN40"
214 #define SPL_ARCH_W32X86         "W32X86"
215 #define SPL_ARCH_W32MIPS        "W32MIPS"
216 #define SPL_ARCH_W32ALPHA       "W32ALPHA"
217 #define SPL_ARCH_W32PPC         "W32PPC"
218 #define SPL_ARCH_IA64           "IA64"
219 #define SPL_ARCH_X64            "x64"
220
221 static const struct table_node archi_table[]= {
222
223         {"Windows 4.0",          SPL_ARCH_WIN40,        0 },
224         {"Windows NT x86",       SPL_ARCH_W32X86,       2 },
225         {"Windows NT R4000",     SPL_ARCH_W32MIPS,      2 },
226         {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA,     2 },
227         {"Windows NT PowerPC",   SPL_ARCH_W32PPC,       2 },
228         {"Windows IA64",         SPL_ARCH_IA64,         3 },
229         {"Windows x64",          SPL_ARCH_X64,          3 },
230         {NULL,                   "",            -1 }
231 };
232
233
234 /****************************************************************************
235  generate a new TDB_DATA key for storing a printer
236 ****************************************************************************/
237
238 static TDB_DATA make_printer_tdbkey(TALLOC_CTX *ctx, const char *sharename )
239 {
240         fstring share;
241         char *keystr = NULL;
242         TDB_DATA key;
243
244         fstrcpy(share, sharename);
245         strlower_m(share);
246
247         keystr = talloc_asprintf(ctx, "%s%s", PRINTERS_PREFIX, share);
248         key = string_term_tdb_data(keystr ? keystr : "");
249
250         return key;
251 }
252
253 /****************************************************************************
254  generate a new TDB_DATA key for storing a printer security descriptor
255 ****************************************************************************/
256
257 static TDB_DATA make_printers_secdesc_tdbkey(TALLOC_CTX *ctx,
258                                         const char* sharename  )
259 {
260         fstring share;
261         char *keystr = NULL;
262         TDB_DATA key;
263
264         fstrcpy(share, sharename );
265         strlower_m(share);
266
267         keystr = talloc_asprintf(ctx, "%s%s", SECDESC_PREFIX, share);
268         key = string_term_tdb_data(keystr ? keystr : "");
269
270         return key;
271 }
272
273 /****************************************************************************
274 ****************************************************************************/
275
276 static bool upgrade_to_version_3(void)
277 {
278         TDB_DATA kbuf, newkey, dbuf;
279  
280         DEBUG(0,("upgrade_to_version_3: upgrading print tdb's to version 3\n"));
281  
282         for (kbuf = tdb_firstkey(tdb_drivers); kbuf.dptr;
283                         newkey = tdb_nextkey(tdb_drivers, kbuf), free(kbuf.dptr), kbuf=newkey) {
284
285                 dbuf = tdb_fetch(tdb_drivers, kbuf);
286
287                 if (strncmp((const char *)kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) == 0) {
288                         DEBUG(0,("upgrade_to_version_3:moving form\n"));
289                         if (tdb_store(tdb_forms, kbuf, dbuf, TDB_REPLACE) != 0) {
290                                 SAFE_FREE(dbuf.dptr);
291                                 DEBUG(0,("upgrade_to_version_3: failed to move form. Error (%s).\n", tdb_errorstr(tdb_forms)));
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 form. Error (%s)\n", tdb_errorstr(tdb_drivers)));
297                                 return False;
298                         }
299                 }
300  
301                 if (strncmp((const char *)kbuf.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX)) == 0) {
302                         DEBUG(0,("upgrade_to_version_3:moving printer\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 printer. 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 printer. Error (%s)\n", tdb_errorstr(tdb_drivers)));
311                                 return False;
312                         }
313                 }
314  
315                 if (strncmp((const char *)kbuf.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX)) == 0) {
316                         DEBUG(0,("upgrade_to_version_3:moving secdesc\n"));
317                         if (tdb_store(tdb_printers, kbuf, dbuf, TDB_REPLACE) != 0) {
318                                 SAFE_FREE(dbuf.dptr);
319                                 DEBUG(0,("upgrade_to_version_3: failed to move secdesc. Error (%s)\n", tdb_errorstr(tdb_printers)));
320                                 return False;
321                         }
322                         if (tdb_delete(tdb_drivers, kbuf) != 0) {
323                                 SAFE_FREE(dbuf.dptr);
324                                 DEBUG(0,("upgrade_to_version_3: failed to delete secdesc. Error (%s)\n", tdb_errorstr(tdb_drivers)));
325                                 return False;
326                         }
327                 }
328  
329                 SAFE_FREE(dbuf.dptr);
330         }
331
332         return True;
333 }
334
335 /*******************************************************************
336  Fix an issue with security descriptors.  Printer sec_desc must 
337  use more than the generic bits that were previously used 
338  in <= 3.0.14a.  They must also have a owner and group SID assigned.
339  Otherwise, any printers than have been migrated to a Windows 
340  host using printmig.exe will not be accessible.
341 *******************************************************************/
342
343 static int sec_desc_upg_fn( TDB_CONTEXT *the_tdb, TDB_DATA key,
344                             TDB_DATA data, void *state )
345 {
346         prs_struct ps;
347         SEC_DESC_BUF *sd_orig = NULL;
348         SEC_DESC_BUF *sd_new, *sd_store;
349         SEC_DESC *sec, *new_sec;
350         TALLOC_CTX *ctx = state;
351         int result, i;
352         uint32 sd_size;
353         size_t size_new_sec;
354
355         if (!data.dptr || data.dsize == 0) {
356                 return 0;
357         }
358
359         if ( strncmp((const char *) key.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX) ) != 0 ) {
360                 return 0;
361         }
362
363         /* upgrade the security descriptor */
364
365         ZERO_STRUCT( ps );
366
367         prs_init_empty( &ps, ctx, UNMARSHALL );
368         prs_give_memory( &ps, (char *)data.dptr, data.dsize, False );
369
370         if ( !sec_io_desc_buf( "sec_desc_upg_fn", &sd_orig, &ps, 1 ) ) {
371                 /* delete bad entries */
372                 DEBUG(0,("sec_desc_upg_fn: Failed to parse original sec_desc for %si.  Deleting....\n",
373                         (const char *)key.dptr ));
374                 tdb_delete( tdb_printers, key );
375                 prs_mem_free( &ps );
376                 return 0;
377         }
378
379         if (!sd_orig) {
380                 prs_mem_free( &ps );
381                 return 0;
382         }
383         sec = sd_orig->sd;
384                 
385         /* is this even valid? */
386         
387         if ( !sec->dacl ) {
388                 prs_mem_free( &ps );
389                 return 0;
390         }
391                 
392         /* update access masks */
393         
394         for ( i=0; i<sec->dacl->num_aces; i++ ) {
395                 switch ( sec->dacl->aces[i].access_mask ) {
396                         case (GENERIC_READ_ACCESS | GENERIC_WRITE_ACCESS | GENERIC_EXECUTE_ACCESS):
397                                 sec->dacl->aces[i].access_mask = PRINTER_ACE_PRINT;
398                                 break;
399                                 
400                         case GENERIC_ALL_ACCESS:
401                                 sec->dacl->aces[i].access_mask = PRINTER_ACE_FULL_CONTROL;
402                                 break;
403                                 
404                         case READ_CONTROL_ACCESS:
405                                 sec->dacl->aces[i].access_mask = PRINTER_ACE_MANAGE_DOCUMENTS;
406                         
407                         default:        /* no change */
408                                 break;
409                 }
410         }
411
412         /* create a new SEC_DESC with the appropriate owner and group SIDs */
413
414         new_sec = make_sec_desc( ctx, SEC_DESC_REVISION, SEC_DESC_SELF_RELATIVE,
415                                  &global_sid_Builtin_Administrators,
416                                  &global_sid_Builtin_Administrators,
417                                  NULL, NULL, &size_new_sec );
418         if (!new_sec) {
419                 prs_mem_free( &ps );
420                 return 0;
421         }
422         sd_new = make_sec_desc_buf( ctx, size_new_sec, new_sec );
423         if (!sd_new) {
424                 prs_mem_free( &ps );
425                 return 0;
426         }
427
428         if ( !(sd_store = sec_desc_merge( ctx, sd_new, sd_orig )) ) {
429                 DEBUG(0,("sec_desc_upg_fn: Failed to update sec_desc for %s\n", key.dptr ));
430                 prs_mem_free( &ps );
431                 return 0;
432         }
433         
434         prs_mem_free( &ps );
435
436         /* store it back */
437         
438         sd_size = ndr_size_security_descriptor(sd_store->sd, 0)
439                 + sizeof(SEC_DESC_BUF);
440         if ( !prs_init(&ps, sd_size, ctx, MARSHALL) ) {
441                 DEBUG(0,("sec_desc_upg_fn: Failed to allocate prs memory for %s\n", key.dptr ));
442                 return 0;
443         }
444
445         if ( !sec_io_desc_buf( "sec_desc_upg_fn", &sd_store, &ps, 1 ) ) {
446                 DEBUG(0,("sec_desc_upg_fn: Failed to parse new sec_desc for %s\n", key.dptr ));
447                 prs_mem_free( &ps );
448                 return 0;
449         }
450
451         data.dptr = (uint8 *)prs_data_p( &ps );
452         data.dsize = sd_size;
453         
454         result = tdb_store( tdb_printers, key, data, TDB_REPLACE );
455
456         prs_mem_free( &ps );
457         
458         /* 0 to continue and non-zero to stop traversal */
459
460         return (result == -1);
461 }
462
463 /*******************************************************************
464 *******************************************************************/
465
466 static bool upgrade_to_version_4(void)
467 {
468         TALLOC_CTX *ctx;
469         int result;
470
471         DEBUG(0,("upgrade_to_version_4: upgrading printer security descriptors\n"));
472
473         if ( !(ctx = talloc_init( "upgrade_to_version_4" )) ) 
474                 return False;
475
476         result = tdb_traverse( tdb_printers, sec_desc_upg_fn, ctx );
477
478         talloc_destroy( ctx );
479
480         return ( result != -1 );
481 }
482
483 /*******************************************************************
484  Fix an issue with security descriptors.  Printer sec_desc must 
485  use more than the generic bits that were previously used 
486  in <= 3.0.14a.  They must also have a owner and group SID assigned.
487  Otherwise, any printers than have been migrated to a Windows 
488  host using printmig.exe will not be accessible.
489 *******************************************************************/
490
491 static int normalize_printers_fn( TDB_CONTEXT *the_tdb, TDB_DATA key,
492                                   TDB_DATA data, void *state )
493 {
494         TALLOC_CTX *ctx = talloc_tos();
495         TDB_DATA new_key;
496
497         if (!data.dptr || data.dsize == 0)
498                 return 0;
499
500         /* upgrade printer records and security descriptors */
501
502         if ( strncmp((const char *) key.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX) ) == 0 ) {
503                 new_key = make_printer_tdbkey(ctx, (const char *)key.dptr+strlen(PRINTERS_PREFIX) );
504         }
505         else if ( strncmp((const char *) key.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX) ) == 0 ) {
506                 new_key = make_printers_secdesc_tdbkey(ctx, (const char *)key.dptr+strlen(SECDESC_PREFIX) );
507         }
508         else {
509                 /* ignore this record */
510                 return 0;
511         }
512
513         /* delete the original record and store under the normalized key */
514
515         if ( tdb_delete( the_tdb, key ) != 0 ) {
516                 DEBUG(0,("normalize_printers_fn: tdb_delete for [%s] failed!\n", 
517                         key.dptr));
518                 return 1;
519         }
520
521         if ( tdb_store( the_tdb, new_key, data, TDB_REPLACE) != 0 ) {
522                 DEBUG(0,("normalize_printers_fn: failed to store new record for [%s]!\n",
523                         key.dptr));
524                 return 1;
525         }
526
527         return 0;
528 }
529
530 /*******************************************************************
531 *******************************************************************/
532
533 static bool upgrade_to_version_5(void)
534 {
535         TALLOC_CTX *ctx;
536         int result;
537
538         DEBUG(0,("upgrade_to_version_5: normalizing printer keys\n"));
539
540         if ( !(ctx = talloc_init( "upgrade_to_version_5" )) ) 
541                 return False;
542
543         result = tdb_traverse( tdb_printers, normalize_printers_fn, NULL );
544
545         talloc_destroy( ctx );
546
547         return ( result != -1 );
548 }
549
550 /****************************************************************************
551  Open the NT printing tdbs. Done once before fork().
552 ****************************************************************************/
553
554 bool nt_printing_init(struct messaging_context *msg_ctx)
555 {
556         const char *vstring = "INFO/version";
557         WERROR win_rc;
558         int32 vers_id;
559
560         if ( tdb_drivers && tdb_printers && tdb_forms )
561                 return True;
562  
563         if (tdb_drivers)
564                 tdb_close(tdb_drivers);
565         tdb_drivers = tdb_open_log(state_path("ntdrivers.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
566         if (!tdb_drivers) {
567                 DEBUG(0,("nt_printing_init: Failed to open nt drivers database %s (%s)\n",
568                         state_path("ntdrivers.tdb"), strerror(errno) ));
569                 return False;
570         }
571  
572         if (tdb_printers)
573                 tdb_close(tdb_printers);
574         tdb_printers = tdb_open_log(state_path("ntprinters.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
575         if (!tdb_printers) {
576                 DEBUG(0,("nt_printing_init: Failed to open nt printers database %s (%s)\n",
577                         state_path("ntprinters.tdb"), strerror(errno) ));
578                 return False;
579         }
580  
581         if (tdb_forms)
582                 tdb_close(tdb_forms);
583         tdb_forms = tdb_open_log(state_path("ntforms.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
584         if (!tdb_forms) {
585                 DEBUG(0,("nt_printing_init: Failed to open nt forms database %s (%s)\n",
586                         state_path("ntforms.tdb"), strerror(errno) ));
587                 return False;
588         }
589  
590         /* handle a Samba upgrade */
591         
592         vers_id = tdb_fetch_int32(tdb_drivers, vstring);
593         if (vers_id == -1) {
594                 DEBUG(10, ("Fresh database\n"));
595                 tdb_store_int32( tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_5 );
596                 vers_id = NTDRIVERS_DATABASE_VERSION_5;
597         }
598
599         if ( vers_id != NTDRIVERS_DATABASE_VERSION_5 ) {
600
601                 if ((vers_id == NTDRIVERS_DATABASE_VERSION_1) || (IREV(vers_id) == NTDRIVERS_DATABASE_VERSION_1)) { 
602                         if (!upgrade_to_version_3())
603                                 return False;
604                         tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_3);
605                         vers_id = NTDRIVERS_DATABASE_VERSION_3;
606                 } 
607                 
608                 if ((vers_id == NTDRIVERS_DATABASE_VERSION_2) || (IREV(vers_id) == NTDRIVERS_DATABASE_VERSION_2)) {
609                         /* Written on a bigendian machine with old fetch_int code. Save as le. */
610                         /* The only upgrade between V2 and V3 is to save the version in little-endian. */
611                         tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_3);
612                         vers_id = NTDRIVERS_DATABASE_VERSION_3;
613                 }
614
615                 if (vers_id == NTDRIVERS_DATABASE_VERSION_3 ) {
616                         if ( !upgrade_to_version_4() )
617                                 return False;
618                         tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_4);
619                         vers_id = NTDRIVERS_DATABASE_VERSION_4;
620                 }
621
622                 if (vers_id == NTDRIVERS_DATABASE_VERSION_4 ) {
623                         if ( !upgrade_to_version_5() )
624                                 return False;
625                         tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_5);
626                         vers_id = NTDRIVERS_DATABASE_VERSION_5;
627                 }
628
629
630                 if ( vers_id != NTDRIVERS_DATABASE_VERSION_5 ) {
631                         DEBUG(0,("nt_printing_init: Unknown printer database version [%d]\n", vers_id));
632                         return False;
633                 }
634         }
635         
636         update_c_setprinter(True);
637
638         /*
639          * register callback to handle updating printers as new
640          * drivers are installed
641          */
642
643         messaging_register(msg_ctx, NULL, MSG_PRINTER_DRVUPGRADE,
644                            do_drv_upgrade_printer);
645
646         /*
647          * register callback to handle updating printer data
648          * when a driver is initialized
649          */
650
651         messaging_register(msg_ctx, NULL, MSG_PRINTERDATA_INIT_RESET,
652                            reset_all_printerdata);
653
654         /* of course, none of the message callbacks matter if you don't
655            tell messages.c that you interested in receiving PRINT_GENERAL 
656            msgs.  This is done in claim_connection() */
657
658
659         if ( lp_security() == SEC_ADS ) {
660                 win_rc = check_published_printers();
661                 if (!W_ERROR_IS_OK(win_rc))
662                         DEBUG(0, ("nt_printing_init: error checking published printers: %s\n", win_errstr(win_rc)));
663         }
664
665         return True;
666 }
667
668 /*******************************************************************
669  Function to allow filename parsing "the old way".
670 ********************************************************************/
671
672 static char *driver_unix_convert(connection_struct *conn,
673                 const char *old_name,
674                 SMB_STRUCT_STAT *pst)
675 {
676         TALLOC_CTX *ctx = talloc_tos();
677         char *name = talloc_strdup(ctx, old_name);
678         char *new_name = NULL;
679
680         if (!name) {
681                 return NULL;
682         }
683         unix_format(name);
684         name = unix_clean_name(ctx, name);
685         if (!name) {
686                 return NULL;
687         }
688         trim_string(name,"/","/");
689         unix_convert(ctx,conn, name, false, &new_name, NULL, pst);
690         return new_name;
691 }
692
693 /*******************************************************************
694  tdb traversal function for counting printers.
695 ********************************************************************/
696
697 static int traverse_counting_printers(TDB_CONTEXT *t, TDB_DATA key,
698                                       TDB_DATA data, void *context)
699 {
700         int *printer_count = (int*)context;
701  
702         if (memcmp(PRINTERS_PREFIX, key.dptr, sizeof(PRINTERS_PREFIX)-1) == 0) {
703                 (*printer_count)++;
704                 DEBUG(10,("traverse_counting_printers: printer = [%s]  printer_count = %d\n", key.dptr, *printer_count));
705         }
706  
707         return 0;
708 }
709  
710 /*******************************************************************
711  Update the spooler global c_setprinter. This variable is initialized
712  when the parent smbd starts with the number of existing printers. It
713  is monotonically increased by the current number of printers *after*
714  each add or delete printer RPC. Only Microsoft knows why... JRR020119
715 ********************************************************************/
716
717 uint32 update_c_setprinter(bool initialize)
718 {
719         int32 c_setprinter;
720         int32 printer_count = 0;
721  
722         tdb_lock_bystring(tdb_printers, GLOBAL_C_SETPRINTER);
723  
724         /* Traverse the tdb, counting the printers */
725         tdb_traverse(tdb_printers, traverse_counting_printers, (void *)&printer_count);
726  
727         /* If initializing, set c_setprinter to current printers count
728          * otherwise, bump it by the current printer count
729          */
730         if (!initialize)
731                 c_setprinter = tdb_fetch_int32(tdb_printers, GLOBAL_C_SETPRINTER) + printer_count;
732         else
733                 c_setprinter = printer_count;
734  
735         DEBUG(10,("update_c_setprinter: c_setprinter = %u\n", (unsigned int)c_setprinter));
736         tdb_store_int32(tdb_printers, GLOBAL_C_SETPRINTER, c_setprinter);
737  
738         tdb_unlock_bystring(tdb_printers, GLOBAL_C_SETPRINTER);
739  
740         return (uint32)c_setprinter;
741 }
742
743 /*******************************************************************
744  Get the spooler global c_setprinter, accounting for initialization.
745 ********************************************************************/
746
747 uint32 get_c_setprinter(void)
748 {
749         int32 c_setprinter = tdb_fetch_int32(tdb_printers, GLOBAL_C_SETPRINTER);
750  
751         if (c_setprinter == (int32)-1)
752                 c_setprinter = update_c_setprinter(True);
753  
754         DEBUG(10,("get_c_setprinter: c_setprinter = %d\n", c_setprinter));
755  
756         return (uint32)c_setprinter;
757 }
758
759 /****************************************************************************
760  Get builtin form struct list.
761 ****************************************************************************/
762
763 int get_builtin_ntforms(nt_forms_struct **list)
764 {
765         *list = (nt_forms_struct *)memdup(&default_forms[0], sizeof(default_forms));
766         if (!*list) {
767                 return 0;
768         }
769         return sizeof(default_forms) / sizeof(default_forms[0]);
770 }
771
772 /****************************************************************************
773  get a builtin form struct
774 ****************************************************************************/
775
776 bool get_a_builtin_ntform(UNISTR2 *uni_formname,nt_forms_struct *form)
777 {
778         int i,count;
779         fstring form_name;
780         unistr2_to_ascii(form_name, uni_formname, sizeof(form_name));
781         DEBUGADD(6,("Looking for builtin form %s \n", form_name));
782         count = sizeof(default_forms) / sizeof(default_forms[0]);
783         for (i=0;i<count;i++) {
784                 if (strequal(form_name,default_forms[i].name)) {
785                         DEBUGADD(6,("Found builtin form %s \n", form_name));
786                         memcpy(form,&default_forms[i],sizeof(*form));
787                         break;
788                 }
789         }
790
791         return (i !=count);
792 }
793
794 /****************************************************************************
795  get a form struct list.
796 ****************************************************************************/
797
798 int get_ntforms(nt_forms_struct **list)
799 {
800         TDB_DATA kbuf, newkey, dbuf;
801         nt_forms_struct form;
802         int ret;
803         int i;
804         int n = 0;
805
806         *list = NULL;
807
808         for (kbuf = tdb_firstkey(tdb_forms);
809              kbuf.dptr;
810              newkey = tdb_nextkey(tdb_forms, kbuf), free(kbuf.dptr), kbuf=newkey) 
811         {
812                 if (strncmp((const char *)kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) != 0) 
813                         continue;
814                 
815                 dbuf = tdb_fetch(tdb_forms, kbuf);
816                 if (!dbuf.dptr) 
817                         continue;
818
819                 fstrcpy(form.name, (const char *)kbuf.dptr+strlen(FORMS_PREFIX));
820                 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "dddddddd",
821                                  &i, &form.flag, &form.width, &form.length, &form.left,
822                                  &form.top, &form.right, &form.bottom);
823                 SAFE_FREE(dbuf.dptr);
824                 if (ret != dbuf.dsize) 
825                         continue;
826
827                 *list = SMB_REALLOC_ARRAY(*list, nt_forms_struct, n+1);
828                 if (!*list) {
829                         DEBUG(0,("get_ntforms: Realloc fail.\n"));
830                         return 0;
831                 }
832                 (*list)[n] = form;
833                 n++;
834         }
835         
836
837         return n;
838 }
839
840 /****************************************************************************
841 write a form struct list
842 ****************************************************************************/
843
844 int write_ntforms(nt_forms_struct **list, int number)
845 {
846         TALLOC_CTX *ctx = talloc_tos();
847         char *buf = NULL;
848         char *key = NULL;
849         int len;
850         TDB_DATA dbuf;
851         int i;
852
853         for (i=0;i<number;i++) {
854                 /* save index, so list is rebuilt in correct order */
855                 len = tdb_pack(NULL, 0, "dddddddd",
856                                i, (*list)[i].flag, (*list)[i].width, (*list)[i].length,
857                                (*list)[i].left, (*list)[i].top, (*list)[i].right,
858                                (*list)[i].bottom);
859                 if (!len) {
860                         continue;
861                 }
862                 buf = TALLOC_ARRAY(ctx, char, len);
863                 if (!buf) {
864                         return 0;
865                 }
866                 len = tdb_pack((uint8 *)buf, len, "dddddddd",
867                                i, (*list)[i].flag, (*list)[i].width, (*list)[i].length,
868                                (*list)[i].left, (*list)[i].top, (*list)[i].right,
869                                (*list)[i].bottom);
870                 key = talloc_asprintf(ctx, "%s%s", FORMS_PREFIX, (*list)[i].name);
871                 if (!key) {
872                         return 0;
873                 }
874                 dbuf.dsize = len;
875                 dbuf.dptr = (uint8 *)buf;
876                 if (tdb_store_bystring(tdb_forms, key, dbuf, TDB_REPLACE) != 0) {
877                         TALLOC_FREE(key);
878                         TALLOC_FREE(buf);
879                         break;
880                 }
881                 TALLOC_FREE(key);
882                 TALLOC_FREE(buf);
883        }
884
885        return i;
886 }
887
888 /****************************************************************************
889 add a form struct at the end of the list
890 ****************************************************************************/
891 bool add_a_form(nt_forms_struct **list, const FORM *form, int *count)
892 {
893         int n=0;
894         bool update;
895         fstring form_name;
896
897         /*
898          * NT tries to add forms even when
899          * they are already in the base
900          * only update the values if already present
901          */
902
903         update=False;
904         
905         unistr2_to_ascii(form_name, &form->name, sizeof(form_name));
906         for (n=0; n<*count; n++) {
907                 if ( strequal((*list)[n].name, form_name) ) {
908                         update=True;
909                         break;
910                 }
911         }
912
913         if (update==False) {
914                 if((*list=SMB_REALLOC_ARRAY(*list, nt_forms_struct, n+1)) == NULL) {
915                         DEBUG(0,("add_a_form: failed to enlarge forms list!\n"));
916                         return False;
917                 }
918                 unistr2_to_ascii((*list)[n].name, &form->name, sizeof((*list)[n].name));
919                 (*count)++;
920         }
921         
922         (*list)[n].flag=form->flags;
923         (*list)[n].width=form->size_x;
924         (*list)[n].length=form->size_y;
925         (*list)[n].left=form->left;
926         (*list)[n].top=form->top;
927         (*list)[n].right=form->right;
928         (*list)[n].bottom=form->bottom;
929
930         DEBUG(6,("add_a_form: Successfully %s form [%s]\n", 
931                 update ? "updated" : "added", form_name));
932
933         return True;
934 }
935
936 /****************************************************************************
937  Delete a named form struct.
938 ****************************************************************************/
939
940 bool delete_a_form(nt_forms_struct **list, UNISTR2 *del_name, int *count, WERROR *ret)
941 {
942         char *key = NULL;
943         int n=0;
944         fstring form_name;
945
946         *ret = WERR_OK;
947
948         unistr2_to_ascii(form_name, del_name, sizeof(form_name));
949
950         for (n=0; n<*count; n++) {
951                 if (!strncmp((*list)[n].name, form_name, strlen(form_name))) {
952                         DEBUG(103, ("delete_a_form, [%s] in list\n", form_name));
953                         break;
954                 }
955         }
956
957         if (n == *count) {
958                 DEBUG(10,("delete_a_form, [%s] not found\n", form_name));
959                 *ret = WERR_INVALID_PARAM;
960                 return False;
961         }
962
963         if (asprintf(&key, "%s%s", FORMS_PREFIX, (*list)[n].name) < 0) {
964                 *ret = WERR_NOMEM;
965                 return false;
966         }
967         if (tdb_delete_bystring(tdb_forms, key) != 0) {
968                 SAFE_FREE(key);
969                 *ret = WERR_NOMEM;
970                 return False;
971         }
972         SAFE_FREE(key);
973         return true;
974 }
975
976 /****************************************************************************
977  Update a form struct.
978 ****************************************************************************/
979
980 void update_a_form(nt_forms_struct **list, const FORM *form, int count)
981 {
982         int n=0;
983         fstring form_name;
984         unistr2_to_ascii(form_name, &(form->name), sizeof(form_name));
985
986         DEBUG(106, ("[%s]\n", form_name));
987         for (n=0; n<count; n++) {
988                 DEBUGADD(106, ("n [%d]:[%s]\n", n, (*list)[n].name));
989                 if (!strncmp((*list)[n].name, form_name, strlen(form_name)))
990                         break;
991         }
992
993         if (n==count) return;
994
995         (*list)[n].flag=form->flags;
996         (*list)[n].width=form->size_x;
997         (*list)[n].length=form->size_y;
998         (*list)[n].left=form->left;
999         (*list)[n].top=form->top;
1000         (*list)[n].right=form->right;
1001         (*list)[n].bottom=form->bottom;
1002 }
1003
1004 /****************************************************************************
1005  Get the nt drivers list.
1006  Traverse the database and look-up the matching names.
1007 ****************************************************************************/
1008 int get_ntdrivers(fstring **list, const char *architecture, uint32 version)
1009 {
1010         int total=0;
1011         const char *short_archi;
1012         char *key = NULL;
1013         TDB_DATA kbuf, newkey;
1014
1015         short_archi = get_short_archi(architecture);
1016         if (!short_archi) {
1017                 return 0;
1018         }
1019
1020         if (asprintf(&key, "%s%s/%d/", DRIVERS_PREFIX,
1021                                 short_archi, version) < 0) {
1022                 return 0;
1023         }
1024
1025         for (kbuf = tdb_firstkey(tdb_drivers);
1026              kbuf.dptr;
1027              newkey = tdb_nextkey(tdb_drivers, kbuf), free(kbuf.dptr), kbuf=newkey) {
1028
1029                 if (strncmp((const char *)kbuf.dptr, key, strlen(key)) != 0)
1030                         continue;
1031
1032                 if((*list = SMB_REALLOC_ARRAY(*list, fstring, total+1)) == NULL) {
1033                         DEBUG(0,("get_ntdrivers: failed to enlarge list!\n"));
1034                         SAFE_FREE(key);
1035                         return -1;
1036                 }
1037
1038                 fstrcpy((*list)[total], (const char *)kbuf.dptr+strlen(key));
1039                 total++;
1040         }
1041
1042         SAFE_FREE(key);
1043         return(total);
1044 }
1045
1046 /****************************************************************************
1047  Function to do the mapping between the long architecture name and
1048  the short one.
1049 ****************************************************************************/
1050
1051 const char *get_short_archi(const char *long_archi)
1052 {
1053         int i=-1;
1054
1055         DEBUG(107,("Getting architecture dependant directory\n"));
1056         do {
1057                 i++;
1058         } while ( (archi_table[i].long_archi!=NULL ) &&
1059                   StrCaseCmp(long_archi, archi_table[i].long_archi) );
1060
1061         if (archi_table[i].long_archi==NULL) {
1062                 DEBUGADD(10,("Unknown architecture [%s] !\n", long_archi));
1063                 return NULL;
1064         }
1065
1066         /* this might be client code - but shouldn't this be an fstrcpy etc? */
1067
1068         DEBUGADD(108,("index: [%d]\n", i));
1069         DEBUGADD(108,("long architecture: [%s]\n", archi_table[i].long_archi));
1070         DEBUGADD(108,("short architecture: [%s]\n", archi_table[i].short_archi));
1071
1072         return archi_table[i].short_archi;
1073 }
1074
1075 /****************************************************************************
1076  Version information in Microsoft files is held in a VS_VERSION_INFO structure.
1077  There are two case to be covered here: PE (Portable Executable) and NE (New
1078  Executable) files. Both files support the same INFO structure, but PE files
1079  store the signature in unicode, and NE files store it as !unicode.
1080  returns -1 on error, 1 on version info found, and 0 on no version info found.
1081 ****************************************************************************/
1082
1083 static int get_file_version(files_struct *fsp, char *fname,uint32 *major, uint32 *minor)
1084 {
1085         int     i;
1086         char    *buf = NULL;
1087         ssize_t byte_count;
1088
1089         if ((buf=(char *)SMB_MALLOC(DOS_HEADER_SIZE)) == NULL) {
1090                 DEBUG(0,("get_file_version: PE file [%s] DOS Header malloc failed bytes = %d\n",
1091                                 fname, DOS_HEADER_SIZE));
1092                 goto error_exit;
1093         }
1094
1095         if ((byte_count = vfs_read_data(fsp, buf, DOS_HEADER_SIZE)) < DOS_HEADER_SIZE) {
1096                 DEBUG(3,("get_file_version: File [%s] DOS header too short, bytes read = %lu\n",
1097                          fname, (unsigned long)byte_count));
1098                 goto no_version_info;
1099         }
1100
1101         /* Is this really a DOS header? */
1102         if (SVAL(buf,DOS_HEADER_MAGIC_OFFSET) != DOS_HEADER_MAGIC) {
1103                 DEBUG(6,("get_file_version: File [%s] bad DOS magic = 0x%x\n",
1104                                 fname, SVAL(buf,DOS_HEADER_MAGIC_OFFSET)));
1105                 goto no_version_info;
1106         }
1107
1108         /* Skip OEM header (if any) and the DOS stub to start of Windows header */
1109         if (SMB_VFS_LSEEK(fsp, SVAL(buf,DOS_HEADER_LFANEW_OFFSET), SEEK_SET) == (SMB_OFF_T)-1) {
1110                 DEBUG(3,("get_file_version: File [%s] too short, errno = %d\n",
1111                                 fname, errno));
1112                 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
1113                 goto no_version_info;
1114         }
1115
1116         /* Note: DOS_HEADER_SIZE and NE_HEADER_SIZE are incidentally same */
1117         if ((byte_count = vfs_read_data(fsp, buf, NE_HEADER_SIZE)) < NE_HEADER_SIZE) {
1118                 DEBUG(3,("get_file_version: File [%s] Windows header too short, bytes read = %lu\n",
1119                          fname, (unsigned long)byte_count));
1120                 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
1121                 goto no_version_info;
1122         }
1123
1124         /* The header may be a PE (Portable Executable) or an NE (New Executable) */
1125         if (IVAL(buf,PE_HEADER_SIGNATURE_OFFSET) == PE_HEADER_SIGNATURE) {
1126                 unsigned int num_sections;
1127                 unsigned int section_table_bytes;
1128
1129                 /* Just skip over optional header to get to section table */
1130                 if (SMB_VFS_LSEEK(fsp,
1131                                 SVAL(buf,PE_HEADER_OPTIONAL_HEADER_SIZE)-(NE_HEADER_SIZE-PE_HEADER_SIZE),
1132                                 SEEK_CUR) == (SMB_OFF_T)-1) {
1133                         DEBUG(3,("get_file_version: File [%s] Windows optional header too short, errno = %d\n",
1134                                 fname, errno));
1135                         goto error_exit;
1136                 }
1137
1138                 /* get the section table */
1139                 num_sections        = SVAL(buf,PE_HEADER_NUMBER_OF_SECTIONS);
1140                 section_table_bytes = num_sections * PE_HEADER_SECT_HEADER_SIZE;
1141                 if (section_table_bytes == 0)
1142                         goto error_exit;
1143
1144                 SAFE_FREE(buf);
1145                 if ((buf=(char *)SMB_MALLOC(section_table_bytes)) == NULL) {
1146                         DEBUG(0,("get_file_version: PE file [%s] section table malloc failed bytes = %d\n",
1147                                         fname, section_table_bytes));
1148                         goto error_exit;
1149                 }
1150
1151                 if ((byte_count = vfs_read_data(fsp, buf, section_table_bytes)) < section_table_bytes) {
1152                         DEBUG(3,("get_file_version: PE file [%s] Section header too short, bytes read = %lu\n",
1153                                  fname, (unsigned long)byte_count));
1154                         goto error_exit;
1155                 }
1156
1157                 /* Iterate the section table looking for the resource section ".rsrc" */
1158                 for (i = 0; i < num_sections; i++) {
1159                         int sec_offset = i * PE_HEADER_SECT_HEADER_SIZE;
1160
1161                         if (strcmp(".rsrc", &buf[sec_offset+PE_HEADER_SECT_NAME_OFFSET]) == 0) {
1162                                 unsigned int section_pos   = IVAL(buf,sec_offset+PE_HEADER_SECT_PTR_DATA_OFFSET);
1163                                 unsigned int section_bytes = IVAL(buf,sec_offset+PE_HEADER_SECT_SIZE_DATA_OFFSET);
1164
1165                                 if (section_bytes == 0)
1166                                         goto error_exit;
1167
1168                                 SAFE_FREE(buf);
1169                                 if ((buf=(char *)SMB_MALLOC(section_bytes)) == NULL) {
1170                                         DEBUG(0,("get_file_version: PE file [%s] version malloc failed bytes = %d\n",
1171                                                         fname, section_bytes));
1172                                         goto error_exit;
1173                                 }
1174
1175                                 /* Seek to the start of the .rsrc section info */
1176                                 if (SMB_VFS_LSEEK(fsp, section_pos, SEEK_SET) == (SMB_OFF_T)-1) {
1177                                         DEBUG(3,("get_file_version: PE file [%s] too short for section info, errno = %d\n",
1178                                                         fname, errno));
1179                                         goto error_exit;
1180                                 }
1181
1182                                 if ((byte_count = vfs_read_data(fsp, buf, section_bytes)) < section_bytes) {
1183                                         DEBUG(3,("get_file_version: PE file [%s] .rsrc section too short, bytes read = %lu\n",
1184                                                  fname, (unsigned long)byte_count));
1185                                         goto error_exit;
1186                                 }
1187
1188                                 if (section_bytes < VS_VERSION_INFO_UNICODE_SIZE)
1189                                         goto error_exit;
1190
1191                                 for (i=0; i<section_bytes-VS_VERSION_INFO_UNICODE_SIZE; i++) {
1192                                         /* Scan for 1st 3 unicoded bytes followed by word aligned magic value */
1193                                         if (buf[i] == 'V' && buf[i+1] == '\0' && buf[i+2] == 'S') {
1194                                                 /* Align to next long address */
1195                                                 int pos = (i + sizeof(VS_SIGNATURE)*2 + 3) & 0xfffffffc;
1196
1197                                                 if (IVAL(buf,pos) == VS_MAGIC_VALUE) {
1198                                                         *major = IVAL(buf,pos+VS_MAJOR_OFFSET);
1199                                                         *minor = IVAL(buf,pos+VS_MINOR_OFFSET);
1200
1201                                                         DEBUG(6,("get_file_version: PE file [%s] Version = %08x:%08x (%d.%d.%d.%d)\n",
1202                                                                           fname, *major, *minor,
1203                                                                           (*major>>16)&0xffff, *major&0xffff,
1204                                                                           (*minor>>16)&0xffff, *minor&0xffff));
1205                                                         SAFE_FREE(buf);
1206                                                         return 1;
1207                                                 }
1208                                         }
1209                                 }
1210                         }
1211                 }
1212
1213                 /* Version info not found, fall back to origin date/time */
1214                 DEBUG(10,("get_file_version: PE file [%s] has no version info\n", fname));
1215                 SAFE_FREE(buf);
1216                 return 0;
1217
1218         } else if (SVAL(buf,NE_HEADER_SIGNATURE_OFFSET) == NE_HEADER_SIGNATURE) {
1219                 if (CVAL(buf,NE_HEADER_TARGET_OS_OFFSET) != NE_HEADER_TARGOS_WIN ) {
1220                         DEBUG(3,("get_file_version: NE file [%s] wrong target OS = 0x%x\n",
1221                                         fname, CVAL(buf,NE_HEADER_TARGET_OS_OFFSET)));
1222                         /* At this point, we assume the file is in error. It still could be somthing
1223                          * else besides a NE file, but it unlikely at this point. */
1224                         goto error_exit;
1225                 }
1226
1227                 /* Allocate a bit more space to speed up things */
1228                 SAFE_FREE(buf);
1229                 if ((buf=(char *)SMB_MALLOC(VS_NE_BUF_SIZE)) == NULL) {
1230                         DEBUG(0,("get_file_version: NE file [%s] malloc failed bytes  = %d\n",
1231                                         fname, PE_HEADER_SIZE));
1232                         goto error_exit;
1233                 }
1234
1235                 /* This is a HACK! I got tired of trying to sort through the messy
1236                  * 'NE' file format. If anyone wants to clean this up please have at
1237                  * it, but this works. 'NE' files will eventually fade away. JRR */
1238                 while((byte_count = vfs_read_data(fsp, buf, VS_NE_BUF_SIZE)) > 0) {
1239                         /* Cover case that should not occur in a well formed 'NE' .dll file */
1240                         if (byte_count-VS_VERSION_INFO_SIZE <= 0) break;
1241
1242                         for(i=0; i<byte_count; i++) {
1243                                 /* Fast skip past data that can't possibly match */
1244                                 if (buf[i] != 'V') continue;
1245
1246                                 /* Potential match data crosses buf boundry, move it to beginning
1247                                  * of buf, and fill the buf with as much as it will hold. */
1248                                 if (i>byte_count-VS_VERSION_INFO_SIZE) {
1249                                         int bc;
1250
1251                                         memcpy(buf, &buf[i], byte_count-i);
1252                                         if ((bc = vfs_read_data(fsp, &buf[byte_count-i], VS_NE_BUF_SIZE-
1253                                                                    (byte_count-i))) < 0) {
1254
1255                                                 DEBUG(0,("get_file_version: NE file [%s] Read error, errno=%d\n",
1256                                                                  fname, errno));
1257                                                 goto error_exit;
1258                                         }
1259
1260                                         byte_count = bc + (byte_count - i);
1261                                         if (byte_count<VS_VERSION_INFO_SIZE) break;
1262
1263                                         i = 0;
1264                                 }
1265
1266                                 /* Check that the full signature string and the magic number that
1267                                  * follows exist (not a perfect solution, but the chances that this
1268                                  * occurs in code is, well, remote. Yes I know I'm comparing the 'V'
1269                                  * twice, as it is simpler to read the code. */
1270                                 if (strcmp(&buf[i], VS_SIGNATURE) == 0) {
1271                                         /* Compute skip alignment to next long address */
1272                                         int skip = -(SMB_VFS_LSEEK(fsp, 0, SEEK_CUR) - (byte_count - i) +
1273                                                                  sizeof(VS_SIGNATURE)) & 3;
1274                                         if (IVAL(buf,i+sizeof(VS_SIGNATURE)+skip) != 0xfeef04bd) continue;
1275
1276                                         *major = IVAL(buf,i+sizeof(VS_SIGNATURE)+skip+VS_MAJOR_OFFSET);
1277                                         *minor = IVAL(buf,i+sizeof(VS_SIGNATURE)+skip+VS_MINOR_OFFSET);
1278                                         DEBUG(6,("get_file_version: NE file [%s] Version = %08x:%08x (%d.%d.%d.%d)\n",
1279                                                           fname, *major, *minor,
1280                                                           (*major>>16)&0xffff, *major&0xffff,
1281                                                           (*minor>>16)&0xffff, *minor&0xffff));
1282                                         SAFE_FREE(buf);
1283                                         return 1;
1284                                 }
1285                         }
1286                 }
1287
1288                 /* Version info not found, fall back to origin date/time */
1289                 DEBUG(0,("get_file_version: NE file [%s] Version info not found\n", fname));
1290                 SAFE_FREE(buf);
1291                 return 0;
1292
1293         } else
1294                 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
1295                 DEBUG(3,("get_file_version: File [%s] unknown file format, signature = 0x%x\n",
1296                                 fname, IVAL(buf,PE_HEADER_SIGNATURE_OFFSET)));
1297
1298         no_version_info:
1299                 SAFE_FREE(buf);
1300                 return 0;
1301
1302         error_exit:
1303                 SAFE_FREE(buf);
1304                 return -1;
1305 }
1306
1307 /****************************************************************************
1308 Drivers for Microsoft systems contain multiple files. Often, multiple drivers
1309 share one or more files. During the MS installation process files are checked
1310 to insure that only a newer version of a shared file is installed over an
1311 older version. There are several possibilities for this comparison. If there
1312 is no previous version, the new one is newer (obviously). If either file is
1313 missing the version info structure, compare the creation date (on Unix use
1314 the modification date). Otherwise chose the numerically larger version number.
1315 ****************************************************************************/
1316
1317 static int file_version_is_newer(connection_struct *conn, fstring new_file, fstring old_file)
1318 {
1319         bool use_version = true;
1320         char *filepath = NULL;
1321
1322         uint32 new_major;
1323         uint32 new_minor;
1324         time_t new_create_time;
1325
1326         uint32 old_major;
1327         uint32 old_minor;
1328         time_t old_create_time;
1329
1330         files_struct    *fsp = NULL;
1331         SMB_STRUCT_STAT st;
1332         SMB_STRUCT_STAT stat_buf;
1333
1334         NTSTATUS status;
1335
1336         SET_STAT_INVALID(st);
1337         SET_STAT_INVALID(stat_buf);
1338         new_create_time = (time_t)0;
1339         old_create_time = (time_t)0;
1340
1341         /* Get file version info (if available) for previous file (if it exists) */
1342         filepath = driver_unix_convert(conn,old_file,&stat_buf);
1343         if (!filepath) {
1344                 goto error_exit;
1345         }
1346
1347         status = open_file_ntcreate(conn, NULL, filepath, &stat_buf,
1348                                 FILE_GENERIC_READ,
1349                                 FILE_SHARE_READ|FILE_SHARE_WRITE,
1350                                 FILE_OPEN,
1351                                 0,
1352                                 FILE_ATTRIBUTE_NORMAL,
1353                                 INTERNAL_OPEN_ONLY,
1354                                 NULL, &fsp);
1355
1356         if (!NT_STATUS_IS_OK(status)) {
1357                 /* Old file not found, so by definition new file is in fact newer */
1358                 DEBUG(10,("file_version_is_newer: Can't open old file [%s], errno = %d\n",
1359                                 filepath, errno));
1360                 return 1;
1361
1362         } else {
1363                 int ret = get_file_version(fsp, old_file, &old_major, &old_minor);
1364                 if (ret == -1) {
1365                         goto error_exit;
1366                 }
1367
1368                 if (!ret) {
1369                         DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
1370                                          old_file));
1371                         use_version = false;
1372                         if (SMB_VFS_FSTAT(fsp, &st) == -1) {
1373                                  goto error_exit;
1374                         }
1375                         old_create_time = st.st_mtime;
1376                         DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n", old_create_time));
1377                 }
1378         }
1379         close_file(NULL, fsp, NORMAL_CLOSE);
1380         fsp = NULL;
1381
1382         /* Get file version info (if available) for new file */
1383         filepath = driver_unix_convert(conn,new_file,&stat_buf);
1384         if (!filepath) {
1385                 goto error_exit;
1386         }
1387
1388         status = open_file_ntcreate(conn, NULL, filepath, &stat_buf,
1389                                 FILE_GENERIC_READ,
1390                                 FILE_SHARE_READ|FILE_SHARE_WRITE,
1391                                 FILE_OPEN,
1392                                 0,
1393                                 FILE_ATTRIBUTE_NORMAL,
1394                                 INTERNAL_OPEN_ONLY,
1395                                 NULL, &fsp);
1396
1397         if (!NT_STATUS_IS_OK(status)) {
1398                 /* New file not found, this shouldn't occur if the caller did its job */
1399                 DEBUG(3,("file_version_is_newer: Can't open new file [%s], errno = %d\n",
1400                                 filepath, errno));
1401                 goto error_exit;
1402
1403         } else {
1404                 int ret = get_file_version(fsp, new_file, &new_major, &new_minor);
1405                 if (ret == -1) {
1406                         goto error_exit;
1407                 }
1408
1409                 if (!ret) {
1410                         DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
1411                                          new_file));
1412                         use_version = false;
1413                         if (SMB_VFS_FSTAT(fsp, &st) == -1) {
1414                                 goto error_exit;
1415                         }
1416                         new_create_time = st.st_mtime;
1417                         DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n", new_create_time));
1418                 }
1419         }
1420         close_file(NULL, fsp, NORMAL_CLOSE);
1421         fsp = NULL;
1422
1423         if (use_version && (new_major != old_major || new_minor != old_minor)) {
1424                 /* Compare versions and choose the larger version number */
1425                 if (new_major > old_major ||
1426                         (new_major == old_major && new_minor > old_minor)) {
1427
1428                         DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file, new_file));
1429                         return 1;
1430                 }
1431                 else {
1432                         DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file));
1433                         return 0;
1434                 }
1435
1436         } else {
1437                 /* Compare modification time/dates and choose the newest time/date */
1438                 if (new_create_time > old_create_time) {
1439                         DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file, new_file));
1440                         return 1;
1441                 }
1442                 else {
1443                         DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file));
1444                         return 0;
1445                 }
1446         }
1447
1448         error_exit:
1449                 if(fsp)
1450                         close_file(NULL, fsp, NORMAL_CLOSE);
1451                 return -1;
1452 }
1453
1454 /****************************************************************************
1455 Determine the correct cVersion associated with an architecture and driver
1456 ****************************************************************************/
1457 static uint32 get_correct_cversion(struct pipes_struct *p,
1458                                    const char *architecture,
1459                                    fstring driverpath_in,
1460                                    WERROR *perr)
1461 {
1462         int               cversion;
1463         NTSTATUS          nt_status;
1464         char *driverpath = NULL;
1465         files_struct      *fsp = NULL;
1466         SMB_STRUCT_STAT   st;
1467         connection_struct *conn = NULL;
1468         NTSTATUS status;
1469         char *oldcwd;
1470         fstring printdollar;
1471         int printdollar_snum;
1472
1473         SET_STAT_INVALID(st);
1474
1475         *perr = WERR_INVALID_PARAM;
1476
1477         /* If architecture is Windows 95/98/ME, the version is always 0. */
1478         if (strcmp(architecture, SPL_ARCH_WIN40) == 0) {
1479                 DEBUG(10,("get_correct_cversion: Driver is Win9x, cversion = 0\n"));
1480                 *perr = WERR_OK;
1481                 return 0;
1482         }
1483
1484         /* If architecture is Windows x64, the version is always 3. */
1485         if (strcmp(architecture, SPL_ARCH_X64) == 0) {
1486                 DEBUG(10,("get_correct_cversion: Driver is x64, cversion = 3\n"));
1487                 *perr = WERR_OK;
1488                 return 3;
1489         }
1490
1491         fstrcpy(printdollar, "print$");
1492
1493         printdollar_snum = find_service(printdollar);
1494         if (printdollar_snum == -1) {
1495                 *perr = WERR_NO_SUCH_SHARE;
1496                 return -1;
1497         }
1498
1499         nt_status = create_conn_struct(talloc_tos(), &conn, printdollar_snum,
1500                                        lp_pathname(printdollar_snum),
1501                                        p->server_info, &oldcwd);
1502         if (!NT_STATUS_IS_OK(nt_status)) {
1503                 DEBUG(0,("get_correct_cversion: create_conn_struct "
1504                          "returned %s\n", nt_errstr(nt_status)));
1505                 *perr = ntstatus_to_werror(nt_status);
1506                 return -1;
1507         }
1508
1509         /* Open the driver file (Portable Executable format) and determine the
1510          * deriver the cversion. */
1511         driverpath = talloc_asprintf(talloc_tos(),
1512                                         "%s/%s",
1513                                         architecture,
1514                                         driverpath_in);
1515         if (!driverpath) {
1516                 *perr = WERR_NOMEM;
1517                 goto error_exit;
1518         }
1519
1520         driverpath = driver_unix_convert(conn,driverpath,&st);
1521         if (!driverpath) {
1522                 *perr = WERR_NOMEM;
1523                 goto error_exit;
1524         }
1525
1526         if (!vfs_file_exist(conn, driverpath, &st)) {
1527                 *perr = WERR_BADFILE;
1528                 goto error_exit;
1529         }
1530
1531         status = open_file_ntcreate(conn, NULL, driverpath, &st,
1532                                 FILE_GENERIC_READ,
1533                                 FILE_SHARE_READ|FILE_SHARE_WRITE,
1534                                 FILE_OPEN,
1535                                 0,
1536                                 FILE_ATTRIBUTE_NORMAL,
1537                                 INTERNAL_OPEN_ONLY,
1538                                 NULL, &fsp);
1539
1540         if (!NT_STATUS_IS_OK(status)) {
1541                 DEBUG(3,("get_correct_cversion: Can't open file [%s], errno = %d\n",
1542                                 driverpath, errno));
1543                 *perr = WERR_ACCESS_DENIED;
1544                 goto error_exit;
1545         } else {
1546                 uint32 major;
1547                 uint32 minor;
1548                 int    ret = get_file_version(fsp, driverpath, &major, &minor);
1549                 if (ret == -1) goto error_exit;
1550
1551                 if (!ret) {
1552                         DEBUG(6,("get_correct_cversion: Version info not found [%s]\n", driverpath));
1553                         goto error_exit;
1554                 }
1555
1556                 /*
1557                  * This is a Microsoft'ism. See references in MSDN to VER_FILEVERSION
1558                  * for more details. Version in this case is not just the version of the 
1559                  * file, but the version in the sense of kernal mode (2) vs. user mode
1560                  * (3) drivers. Other bits of the version fields are the version info. 
1561                  * JRR 010716
1562                 */
1563                 cversion = major & 0x0000ffff;
1564                 switch (cversion) {
1565                         case 2: /* WinNT drivers */
1566                         case 3: /* Win2K drivers */
1567                                 break;
1568                         
1569                         default:
1570                                 DEBUG(6,("get_correct_cversion: cversion invalid [%s]  cversion = %d\n", 
1571                                         driverpath, cversion));
1572                                 goto error_exit;
1573                 }
1574
1575                 DEBUG(10,("get_correct_cversion: Version info found [%s]  major = 0x%x  minor = 0x%x\n",
1576                                   driverpath, major, minor));
1577         }
1578
1579         DEBUG(10,("get_correct_cversion: Driver file [%s] cversion = %d\n",
1580                 driverpath, cversion));
1581
1582         goto done;
1583
1584  error_exit:
1585         cversion = -1;
1586  done:
1587         if (fsp != NULL) {
1588                 close_file(NULL, fsp, NORMAL_CLOSE);
1589         }
1590         if (conn != NULL) {
1591                 vfs_ChDir(conn, oldcwd);
1592                 conn_free_internal(conn);
1593         }
1594         if (cversion != -1) {
1595                 *perr = WERR_OK;
1596         }
1597         return cversion;
1598 }
1599
1600 /****************************************************************************
1601 ****************************************************************************/
1602 static WERROR clean_up_driver_struct_level_3(struct pipes_struct *rpc_pipe,
1603                                              NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver)
1604 {
1605         const char *architecture;
1606         fstring new_name;
1607         char *p;
1608         int i;
1609         WERROR err;
1610
1611         /* clean up the driver name.
1612          * we can get .\driver.dll
1613          * or worse c:\windows\system\driver.dll !
1614          */
1615         /* using an intermediate string to not have overlaping memcpy()'s */
1616         if ((p = strrchr(driver->driverpath,'\\')) != NULL) {
1617                 fstrcpy(new_name, p+1);
1618                 fstrcpy(driver->driverpath, new_name);
1619         }
1620
1621         if ((p = strrchr(driver->datafile,'\\')) != NULL) {
1622                 fstrcpy(new_name, p+1);
1623                 fstrcpy(driver->datafile, new_name);
1624         }
1625
1626         if ((p = strrchr(driver->configfile,'\\')) != NULL) {
1627                 fstrcpy(new_name, p+1);
1628                 fstrcpy(driver->configfile, new_name);
1629         }
1630
1631         if ((p = strrchr(driver->helpfile,'\\')) != NULL) {
1632                 fstrcpy(new_name, p+1);
1633                 fstrcpy(driver->helpfile, new_name);
1634         }
1635
1636         if (driver->dependentfiles) {
1637                 for (i=0; *driver->dependentfiles[i]; i++) {
1638                         if ((p = strrchr(driver->dependentfiles[i],'\\')) != NULL) {
1639                                 fstrcpy(new_name, p+1);
1640                                 fstrcpy(driver->dependentfiles[i], new_name);
1641                         }
1642                 }
1643         }
1644
1645         architecture = get_short_archi(driver->environment);
1646         if (!architecture) {
1647                 return WERR_UNKNOWN_PRINTER_DRIVER;
1648         }
1649         
1650         /* jfm:7/16/2000 the client always sends the cversion=0.
1651          * The server should check which version the driver is by reading
1652          * the PE header of driver->driverpath.
1653          *
1654          * For Windows 95/98 the version is 0 (so the value sent is correct)
1655          * For Windows NT (the architecture doesn't matter)
1656          *      NT 3.1: cversion=0
1657          *      NT 3.5/3.51: cversion=1
1658          *      NT 4: cversion=2
1659          *      NT2K: cversion=3
1660          */
1661         if ((driver->cversion = get_correct_cversion(rpc_pipe, architecture,
1662                                                      driver->driverpath,
1663                                                      &err)) == -1)
1664                 return err;
1665
1666         return WERR_OK;
1667 }
1668         
1669 /****************************************************************************
1670 ****************************************************************************/
1671 static WERROR clean_up_driver_struct_level_6(struct pipes_struct *rpc_pipe,
1672                                              NT_PRINTER_DRIVER_INFO_LEVEL_6 *driver)
1673 {
1674         const char *architecture;
1675         fstring new_name;
1676         char *p;
1677         int i;
1678         WERROR err;
1679
1680         /* clean up the driver name.
1681          * we can get .\driver.dll
1682          * or worse c:\windows\system\driver.dll !
1683          */
1684         /* using an intermediate string to not have overlaping memcpy()'s */
1685         if ((p = strrchr(driver->driverpath,'\\')) != NULL) {
1686                 fstrcpy(new_name, p+1);
1687                 fstrcpy(driver->driverpath, new_name);
1688         }
1689
1690         if ((p = strrchr(driver->datafile,'\\')) != NULL) {
1691                 fstrcpy(new_name, p+1);
1692                 fstrcpy(driver->datafile, new_name);
1693         }
1694
1695         if ((p = strrchr(driver->configfile,'\\')) != NULL) {
1696                 fstrcpy(new_name, p+1);
1697                 fstrcpy(driver->configfile, new_name);
1698         }
1699
1700         if ((p = strrchr(driver->helpfile,'\\')) != NULL) {
1701                 fstrcpy(new_name, p+1);
1702                 fstrcpy(driver->helpfile, new_name);
1703         }
1704
1705         if (driver->dependentfiles) {
1706                 for (i=0; *driver->dependentfiles[i]; i++) {
1707                         if ((p = strrchr(driver->dependentfiles[i],'\\')) != NULL) {
1708                                 fstrcpy(new_name, p+1);
1709                                 fstrcpy(driver->dependentfiles[i], new_name);
1710                         }
1711                 }
1712         }
1713
1714         architecture = get_short_archi(driver->environment);
1715         if (!architecture) {
1716                 return WERR_UNKNOWN_PRINTER_DRIVER;
1717         }
1718
1719         /* jfm:7/16/2000 the client always sends the cversion=0.
1720          * The server should check which version the driver is by reading
1721          * the PE header of driver->driverpath.
1722          *
1723          * For Windows 95/98 the version is 0 (so the value sent is correct)
1724          * For Windows NT (the architecture doesn't matter)
1725          *      NT 3.1: cversion=0
1726          *      NT 3.5/3.51: cversion=1
1727          *      NT 4: cversion=2
1728          *      NT2K: cversion=3
1729          */
1730
1731         if ((driver->version = get_correct_cversion(rpc_pipe, architecture,
1732                                                     driver->driverpath,
1733                                                     &err)) == -1)
1734                         return err;
1735
1736         return WERR_OK;
1737 }
1738
1739 /****************************************************************************
1740 ****************************************************************************/
1741 WERROR clean_up_driver_struct(struct pipes_struct *rpc_pipe,
1742                               NT_PRINTER_DRIVER_INFO_LEVEL driver_abstract,
1743                               uint32 level)
1744 {
1745         switch (level) {
1746                 case 3:
1747                 {
1748                         NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver;
1749                         driver=driver_abstract.info_3;
1750                         return clean_up_driver_struct_level_3(rpc_pipe,
1751                                                               driver);
1752                 }
1753                 case 6:
1754                 {
1755                         NT_PRINTER_DRIVER_INFO_LEVEL_6 *driver;
1756                         driver=driver_abstract.info_6;
1757                         return clean_up_driver_struct_level_6(rpc_pipe,
1758                                                               driver);
1759                 }
1760                 default:
1761                         return WERR_INVALID_PARAM;
1762         }
1763 }
1764
1765 /****************************************************************************
1766  This function sucks and should be replaced. JRA.
1767 ****************************************************************************/
1768
1769 static void convert_level_6_to_level3(NT_PRINTER_DRIVER_INFO_LEVEL_3 *dst, NT_PRINTER_DRIVER_INFO_LEVEL_6 *src)
1770 {
1771     dst->cversion  = src->version;
1772
1773     fstrcpy( dst->name, src->name);
1774     fstrcpy( dst->environment, src->environment);
1775     fstrcpy( dst->driverpath, src->driverpath);
1776     fstrcpy( dst->datafile, src->datafile);
1777     fstrcpy( dst->configfile, src->configfile);
1778     fstrcpy( dst->helpfile, src->helpfile);
1779     fstrcpy( dst->monitorname, src->monitorname);
1780     fstrcpy( dst->defaultdatatype, src->defaultdatatype);
1781     dst->dependentfiles = src->dependentfiles;
1782 }
1783
1784 #if 0 /* Debugging function */
1785
1786 static char* ffmt(unsigned char *c){
1787         int i;
1788         static char ffmt_str[17];
1789
1790         for (i=0; i<16; i++) {
1791                 if ((c[i] < ' ') || (c[i] > '~'))
1792                         ffmt_str[i]='.';
1793                 else
1794                         ffmt_str[i]=c[i];
1795         }
1796     ffmt_str[16]='\0';
1797         return ffmt_str;
1798 }
1799
1800 #endif
1801
1802 /****************************************************************************
1803 ****************************************************************************/
1804 WERROR move_driver_to_download_area(struct pipes_struct *p,
1805                                     NT_PRINTER_DRIVER_INFO_LEVEL driver_abstract,
1806                                     uint32 level, WERROR *perr)
1807 {
1808         NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver;
1809         NT_PRINTER_DRIVER_INFO_LEVEL_3 converted_driver;
1810         const char *architecture;
1811         char *new_dir = NULL;
1812         char *old_name = NULL;
1813         char *new_name = NULL;
1814         connection_struct *conn = NULL;
1815         NTSTATUS nt_status;
1816         SMB_STRUCT_STAT st;
1817         int i;
1818         TALLOC_CTX *ctx = talloc_tos();
1819         int ver = 0;
1820         char *oldcwd;
1821         fstring printdollar;
1822         int printdollar_snum;
1823
1824         *perr = WERR_OK;
1825
1826         if (level==3)
1827                 driver=driver_abstract.info_3;
1828         else if (level==6) {
1829                 convert_level_6_to_level3(&converted_driver, driver_abstract.info_6);
1830                 driver = &converted_driver;
1831         } else {
1832                 DEBUG(0,("move_driver_to_download_area: Unknown info level (%u)\n", (unsigned int)level ));
1833                 return WERR_UNKNOWN_LEVEL;
1834         }
1835
1836         architecture = get_short_archi(driver->environment);
1837         if (!architecture) {
1838                 return WERR_UNKNOWN_PRINTER_DRIVER;
1839         }
1840
1841         fstrcpy(printdollar, "print$");
1842
1843         printdollar_snum = find_service(printdollar);
1844         if (printdollar_snum == -1) {
1845                 *perr = WERR_NO_SUCH_SHARE;
1846                 return WERR_NO_SUCH_SHARE;
1847         }
1848
1849         nt_status = create_conn_struct(talloc_tos(), &conn, printdollar_snum,
1850                                        lp_pathname(printdollar_snum),
1851                                        p->server_info, &oldcwd);
1852         if (!NT_STATUS_IS_OK(nt_status)) {
1853                 DEBUG(0,("move_driver_to_download_area: create_conn_struct "
1854                          "returned %s\n", nt_errstr(nt_status)));
1855                 *perr = ntstatus_to_werror(nt_status);
1856                 return *perr;
1857         }
1858
1859         DEBUG(5,("Creating first directory\n"));
1860         new_dir = talloc_asprintf(ctx,
1861                                 "%s/%d",
1862                                 architecture,
1863                                 driver->cversion);
1864         if (!new_dir) {
1865                 *perr = WERR_NOMEM;
1866                 goto err_exit;
1867         }
1868         new_dir = driver_unix_convert(conn,new_dir,&st);
1869         if (!new_dir) {
1870                 *perr = WERR_NOMEM;
1871                 goto err_exit;
1872         }
1873
1874         create_directory(conn, NULL, new_dir);
1875
1876         /* For each driver file, archi\filexxx.yyy, if there is a duplicate file
1877          * listed for this driver which has already been moved, skip it (note:
1878          * drivers may list the same file name several times. Then check if the
1879          * file already exists in archi\cversion\, if so, check that the version
1880          * info (or time stamps if version info is unavailable) is newer (or the
1881          * date is later). If it is, move it to archi\cversion\filexxx.yyy.
1882          * Otherwise, delete the file.
1883          *
1884          * If a file is not moved to archi\cversion\ because of an error, all the
1885          * rest of the 'unmoved' driver files are removed from archi\. If one or
1886          * more of the driver's files was already moved to archi\cversion\, it
1887          * potentially leaves the driver in a partially updated state. Version
1888          * trauma will most likely occur if an client attempts to use any printer
1889          * bound to the driver. Perhaps a rewrite to make sure the moves can be
1890          * done is appropriate... later JRR
1891          */
1892
1893         DEBUG(5,("Moving files now !\n"));
1894
1895         if (driver->driverpath && strlen(driver->driverpath)) {
1896                 new_name = talloc_asprintf(ctx,
1897                                         "%s/%s",
1898                                         architecture,
1899                                         driver->driverpath);
1900                 if (!new_name) {
1901                         *perr = WERR_NOMEM;
1902                         goto err_exit;
1903                 }
1904                 old_name = talloc_asprintf(ctx,
1905                                         "%s/%s",
1906                                         new_dir,
1907                                         driver->driverpath);
1908                 if (!old_name) {
1909                         *perr = WERR_NOMEM;
1910                         goto err_exit;
1911                 }
1912
1913                 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1914                         new_name = driver_unix_convert(conn,new_name,&st);
1915                         if (!new_name) {
1916                                 *perr = WERR_NOMEM;
1917                                 goto err_exit;
1918                         }
1919                         if ( !NT_STATUS_IS_OK(copy_file(ctx,conn, new_name, old_name, OPENX_FILE_EXISTS_TRUNCATE|
1920                                                 OPENX_FILE_CREATE_IF_NOT_EXIST, 0, False))) {
1921                                 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1922                                                 new_name, old_name));
1923                                 *perr = WERR_ACCESS_DENIED;
1924                                 ver = -1;
1925                         }
1926                 }
1927         }
1928
1929         if (driver->datafile && strlen(driver->datafile)) {
1930                 if (!strequal(driver->datafile, driver->driverpath)) {
1931                         new_name = talloc_asprintf(ctx,
1932                                         "%s/%s",
1933                                         architecture,
1934                                         driver->datafile);
1935                         if (!new_name) {
1936                                 *perr = WERR_NOMEM;
1937                                 goto err_exit;
1938                         }
1939                         old_name = talloc_asprintf(ctx,
1940                                         "%s/%s",
1941                                         new_dir,
1942                                         driver->datafile);
1943                         if (!old_name) {
1944                                 *perr = WERR_NOMEM;
1945                                 goto err_exit;
1946                         }
1947                         if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1948                                 new_name = driver_unix_convert(conn,new_name,&st);
1949                                 if (!new_name) {
1950                                         *perr = WERR_NOMEM;
1951                                         goto err_exit;
1952                                 }
1953                                 if ( !NT_STATUS_IS_OK(copy_file(ctx,conn, new_name, old_name, OPENX_FILE_EXISTS_TRUNCATE|
1954                                                 OPENX_FILE_CREATE_IF_NOT_EXIST, 0, False))) {
1955                                         DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1956                                                         new_name, old_name));
1957                                         *perr = WERR_ACCESS_DENIED;
1958                                         ver = -1;
1959                                 }
1960                         }
1961                 }
1962         }
1963
1964         if (driver->configfile && strlen(driver->configfile)) {
1965                 if (!strequal(driver->configfile, driver->driverpath) &&
1966                         !strequal(driver->configfile, driver->datafile)) {
1967                         new_name = talloc_asprintf(ctx,
1968                                                 "%s/%s",
1969                                                 architecture,
1970                                                 driver->configfile);
1971                         if (!new_name) {
1972                                 *perr = WERR_NOMEM;
1973                                 goto err_exit;
1974                         }
1975                         old_name = talloc_asprintf(ctx,
1976                                                 "%s/%s",
1977                                                 new_dir,
1978                                                 driver->configfile);
1979                         if (!old_name) {
1980                                 *perr = WERR_NOMEM;
1981                                 goto err_exit;
1982                         }
1983                         if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1984                                 new_name = driver_unix_convert(conn,new_name,&st);
1985                                 if (!new_name) {
1986                                         *perr = WERR_NOMEM;
1987                                         goto err_exit;
1988                                 }
1989                                 if ( !NT_STATUS_IS_OK(copy_file(ctx,conn, new_name, old_name, OPENX_FILE_EXISTS_TRUNCATE|
1990                                                 OPENX_FILE_CREATE_IF_NOT_EXIST, 0, False))) {
1991                                         DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1992                                                         new_name, old_name));
1993                                         *perr = WERR_ACCESS_DENIED;
1994                                         ver = -1;
1995                                 }
1996                         }
1997                 }
1998         }
1999
2000         if (driver->helpfile && strlen(driver->helpfile)) {
2001                 if (!strequal(driver->helpfile, driver->driverpath) &&
2002                         !strequal(driver->helpfile, driver->datafile) &&
2003                         !strequal(driver->helpfile, driver->configfile)) {
2004                         new_name = talloc_asprintf(ctx,
2005                                         "%s/%s",
2006                                         architecture,
2007                                         driver->helpfile);
2008                         if (!new_name) {
2009                                 *perr = WERR_NOMEM;
2010                                 goto err_exit;
2011                         }
2012                         old_name = talloc_asprintf(ctx,
2013                                         "%s/%s",
2014                                         new_dir,
2015                                         driver->helpfile);
2016                         if (!old_name) {
2017                                 *perr = WERR_NOMEM;
2018                                 goto err_exit;
2019                         }
2020                         if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
2021                                 new_name = driver_unix_convert(conn,new_name,&st);
2022                                 if (!new_name) {
2023                                         *perr = WERR_NOMEM;
2024                                         goto err_exit;
2025                                 }
2026                                 if ( !NT_STATUS_IS_OK(copy_file(ctx,conn, new_name, old_name, OPENX_FILE_EXISTS_TRUNCATE|
2027                                                 OPENX_FILE_CREATE_IF_NOT_EXIST, 0, False))) {
2028                                         DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
2029                                                         new_name, old_name));
2030                                         *perr = WERR_ACCESS_DENIED;
2031                                         ver = -1;
2032                                 }
2033                         }
2034                 }
2035         }
2036
2037         if (driver->dependentfiles) {
2038                 for (i=0; *driver->dependentfiles[i]; i++) {
2039                         if (!strequal(driver->dependentfiles[i], driver->driverpath) &&
2040                                 !strequal(driver->dependentfiles[i], driver->datafile) &&
2041                                 !strequal(driver->dependentfiles[i], driver->configfile) &&
2042                                 !strequal(driver->dependentfiles[i], driver->helpfile)) {
2043                                 int j;
2044                                 for (j=0; j < i; j++) {
2045                                         if (strequal(driver->dependentfiles[i], driver->dependentfiles[j])) {
2046                                                 goto NextDriver;
2047                                         }
2048                                 }
2049
2050                                 new_name = talloc_asprintf(ctx,
2051                                                 "%s/%s",
2052                                                 architecture,
2053                                                 driver->dependentfiles[i]);
2054                                 if (!new_name) {
2055                                         *perr = WERR_NOMEM;
2056                                         goto err_exit;
2057                                 }
2058                                 old_name = talloc_asprintf(ctx,
2059                                                 "%s/%s",
2060                                                 new_dir,
2061                                                 driver->dependentfiles[i]);
2062                                 if (!old_name) {
2063                                         *perr = WERR_NOMEM;
2064                                         goto err_exit;
2065                                 }
2066                                 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
2067                                         new_name = driver_unix_convert(conn,new_name,&st);
2068                                         if (!new_name) {
2069                                                 *perr = WERR_NOMEM;
2070                                                 goto err_exit;
2071                                         }
2072                                         if ( !NT_STATUS_IS_OK(copy_file(ctx,conn, new_name, old_name,
2073                                                         OPENX_FILE_EXISTS_TRUNCATE|
2074                                                         OPENX_FILE_CREATE_IF_NOT_EXIST, 0, False))) {
2075                                                 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
2076                                                                 new_name, old_name));
2077                                                 *perr = WERR_ACCESS_DENIED;
2078                                                 ver = -1;
2079                                         }
2080                                 }
2081                         }
2082                 NextDriver: ;
2083                 }
2084         }
2085
2086   err_exit:
2087
2088         if (conn != NULL) {
2089                 vfs_ChDir(conn, oldcwd);
2090                 conn_free_internal(conn);
2091         }
2092
2093         if (W_ERROR_EQUAL(*perr, WERR_OK)) {
2094                 return WERR_OK;
2095         }
2096         if (ver == -1) {
2097                 return WERR_UNKNOWN_PRINTER_DRIVER;
2098         }
2099         return (*perr);
2100 }
2101
2102 /****************************************************************************
2103 ****************************************************************************/
2104
2105 static uint32 add_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver)
2106 {
2107         TALLOC_CTX *ctx = talloc_tos();
2108         int len, buflen;
2109         const char *architecture;
2110         char *directory = NULL;
2111         fstring temp_name;
2112         char *key = NULL;
2113         uint8 *buf;
2114         int i, ret;
2115         TDB_DATA dbuf;
2116
2117         architecture = get_short_archi(driver->environment);
2118         if (!architecture) {
2119                 return (uint32)-1;
2120         }
2121
2122         /* The names are relative. We store them in the form: \print$\arch\version\driver.xxx
2123          * \\server is added in the rpc server layer.
2124          * It does make sense to NOT store the server's name in the printer TDB.
2125          */
2126
2127         directory = talloc_asprintf(ctx, "\\print$\\%s\\%d\\",
2128                         architecture, driver->cversion);
2129         if (!directory) {
2130                 return (uint32)-1;
2131         }
2132
2133         /* .inf files do not always list a file for each of the four standard files. 
2134          * Don't prepend a path to a null filename, or client claims:
2135          *   "The server on which the printer resides does not have a suitable 
2136          *   <printer driver name> printer driver installed. Click OK if you 
2137          *   wish to install the driver on your local machine."
2138          */
2139         if (strlen(driver->driverpath)) {
2140                 fstrcpy(temp_name, driver->driverpath);
2141                 slprintf(driver->driverpath, sizeof(driver->driverpath)-1, "%s%s", directory, temp_name);
2142         }
2143
2144         if (strlen(driver->datafile)) {
2145                 fstrcpy(temp_name, driver->datafile);
2146                 slprintf(driver->datafile, sizeof(driver->datafile)-1, "%s%s", directory, temp_name);
2147         }
2148
2149         if (strlen(driver->configfile)) {
2150                 fstrcpy(temp_name, driver->configfile);
2151                 slprintf(driver->configfile, sizeof(driver->configfile)-1, "%s%s", directory, temp_name);
2152         }
2153
2154         if (strlen(driver->helpfile)) {
2155                 fstrcpy(temp_name, driver->helpfile);
2156                 slprintf(driver->helpfile, sizeof(driver->helpfile)-1, "%s%s", directory, temp_name);
2157         }
2158
2159         if (driver->dependentfiles) {
2160                 for (i=0; *driver->dependentfiles[i]; i++) {
2161                         fstrcpy(temp_name, driver->dependentfiles[i]);
2162                         slprintf(driver->dependentfiles[i], sizeof(driver->dependentfiles[i])-1, "%s%s", directory, temp_name);
2163                 }
2164         }
2165
2166         key = talloc_asprintf(ctx, "%s%s/%d/%s", DRIVERS_PREFIX,
2167                         architecture, driver->cversion, driver->name);
2168         if (!key) {
2169                 return (uint32)-1;
2170         }
2171
2172         DEBUG(5,("add_a_printer_driver_3: Adding driver with key %s\n", key ));
2173
2174         buf = NULL;
2175         len = buflen = 0;
2176
2177  again:
2178         len = 0;
2179         len += tdb_pack(buf+len, buflen-len, "dffffffff",
2180                         driver->cversion,
2181                         driver->name,
2182                         driver->environment,
2183                         driver->driverpath,
2184                         driver->datafile,
2185                         driver->configfile,
2186                         driver->helpfile,
2187                         driver->monitorname,
2188                         driver->defaultdatatype);
2189
2190         if (driver->dependentfiles) {
2191                 for (i=0; *driver->dependentfiles[i]; i++) {
2192                         len += tdb_pack(buf+len, buflen-len, "f",
2193                                         driver->dependentfiles[i]);
2194                 }
2195         }
2196
2197         if (len != buflen) {
2198                 buf = (uint8 *)SMB_REALLOC(buf, len);
2199                 if (!buf) {
2200                         DEBUG(0,("add_a_printer_driver_3: failed to enlarge buffer\n!"));
2201                         ret = -1;
2202                         goto done;
2203                 }
2204                 buflen = len;
2205                 goto again;
2206         }
2207
2208         dbuf.dptr = buf;
2209         dbuf.dsize = len;
2210
2211         ret = tdb_store_bystring(tdb_drivers, key, dbuf, TDB_REPLACE);
2212
2213 done:
2214         if (ret)
2215                 DEBUG(0,("add_a_printer_driver_3: Adding driver with key %s failed.\n", key ));
2216
2217         SAFE_FREE(buf);
2218         return ret;
2219 }
2220
2221 /****************************************************************************
2222 ****************************************************************************/
2223 static uint32 add_a_printer_driver_6(NT_PRINTER_DRIVER_INFO_LEVEL_6 *driver)
2224 {
2225         NT_PRINTER_DRIVER_INFO_LEVEL_3 info3;
2226
2227         ZERO_STRUCT(info3);
2228         info3.cversion = driver->version;
2229         fstrcpy(info3.name,driver->name);
2230         fstrcpy(info3.environment,driver->environment);
2231         fstrcpy(info3.driverpath,driver->driverpath);
2232         fstrcpy(info3.datafile,driver->datafile);
2233         fstrcpy(info3.configfile,driver->configfile);
2234         fstrcpy(info3.helpfile,driver->helpfile);
2235         fstrcpy(info3.monitorname,driver->monitorname);
2236         fstrcpy(info3.defaultdatatype,driver->defaultdatatype);
2237         info3.dependentfiles = driver->dependentfiles;
2238
2239         return add_a_printer_driver_3(&info3);
2240 }
2241
2242
2243 /****************************************************************************
2244 ****************************************************************************/
2245 static WERROR get_a_printer_driver_3_default(NT_PRINTER_DRIVER_INFO_LEVEL_3 **info_ptr, const char *driver, const char *arch)
2246 {
2247         NT_PRINTER_DRIVER_INFO_LEVEL_3 info;
2248
2249         ZERO_STRUCT(info);
2250
2251         fstrcpy(info.name, driver);
2252         fstrcpy(info.defaultdatatype, "RAW");
2253         
2254         fstrcpy(info.driverpath, "");
2255         fstrcpy(info.datafile, "");
2256         fstrcpy(info.configfile, "");
2257         fstrcpy(info.helpfile, "");
2258
2259         if ((info.dependentfiles= SMB_MALLOC_ARRAY(fstring, 2)) == NULL)
2260                 return WERR_NOMEM;
2261
2262         memset(info.dependentfiles, '\0', 2*sizeof(fstring));
2263         fstrcpy(info.dependentfiles[0], "");
2264
2265         *info_ptr = (NT_PRINTER_DRIVER_INFO_LEVEL_3 *)memdup(&info, sizeof(info));
2266         if (!*info_ptr) {
2267                 SAFE_FREE(info.dependentfiles);
2268                 return WERR_NOMEM;
2269         }
2270         
2271         return WERR_OK;
2272 }
2273
2274 /****************************************************************************
2275 ****************************************************************************/
2276 static WERROR get_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 **info_ptr, fstring drivername, const char *arch, uint32 version)
2277 {
2278         NT_PRINTER_DRIVER_INFO_LEVEL_3 driver;
2279         TDB_DATA dbuf;
2280         const char *architecture;
2281         int len = 0;
2282         int i;
2283         char *key = NULL;
2284
2285         ZERO_STRUCT(driver);
2286
2287         architecture = get_short_archi(arch);
2288         if ( !architecture ) {
2289                 return WERR_UNKNOWN_PRINTER_DRIVER;
2290         }
2291
2292         /* Windows 4.0 (i.e. win9x) should always use a version of 0 */
2293
2294         if ( strcmp( architecture, SPL_ARCH_WIN40 ) == 0 )
2295                 version = 0;
2296
2297         DEBUG(8,("get_a_printer_driver_3: [%s%s/%d/%s]\n", DRIVERS_PREFIX, architecture, version, drivername));
2298
2299         if (asprintf(&key, "%s%s/%d/%s", DRIVERS_PREFIX,
2300                                 architecture, version, drivername) < 0) {
2301                 return WERR_NOMEM;
2302         }
2303
2304         dbuf = tdb_fetch_bystring(tdb_drivers, key);
2305         if (!dbuf.dptr) {
2306                 SAFE_FREE(key);
2307                 return WERR_UNKNOWN_PRINTER_DRIVER;
2308         }
2309
2310         len += tdb_unpack(dbuf.dptr, dbuf.dsize, "dffffffff",
2311                           &driver.cversion,
2312                           driver.name,
2313                           driver.environment,
2314                           driver.driverpath,
2315                           driver.datafile,
2316                           driver.configfile,
2317                           driver.helpfile,
2318                           driver.monitorname,
2319                           driver.defaultdatatype);
2320
2321         i=0;
2322         while (len < dbuf.dsize) {
2323                 driver.dependentfiles = SMB_REALLOC_ARRAY(driver.dependentfiles, fstring, i+2);
2324                 if ( !driver.dependentfiles ) {
2325                         DEBUG(0,("get_a_printer_driver_3: failed to enlarge buffer!\n"));
2326                         break;
2327                 }
2328
2329                 len += tdb_unpack(dbuf.dptr+len, dbuf.dsize-len, "f",
2330                                   &driver.dependentfiles[i]);
2331                 i++;
2332         }
2333
2334         if ( driver.dependentfiles )
2335                 fstrcpy( driver.dependentfiles[i], "" );
2336
2337         SAFE_FREE(dbuf.dptr);
2338         SAFE_FREE(key);
2339
2340         if (len != dbuf.dsize) {
2341                 SAFE_FREE(driver.dependentfiles);
2342
2343                 return get_a_printer_driver_3_default(info_ptr, drivername, arch);
2344         }
2345
2346         *info_ptr = (NT_PRINTER_DRIVER_INFO_LEVEL_3 *)memdup(&driver, sizeof(driver));
2347         if (!*info_ptr) {
2348                 SAFE_FREE(driver.dependentfiles);
2349                 return WERR_NOMEM;
2350         }
2351
2352         return WERR_OK;
2353 }
2354
2355 /****************************************************************************
2356  Debugging function, dump at level 6 the struct in the logs.
2357 ****************************************************************************/
2358
2359 static uint32 dump_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
2360 {
2361         uint32 result;
2362         NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3;
2363         int i;
2364         
2365         DEBUG(20,("Dumping printer driver at level [%d]\n", level));
2366         
2367         switch (level)
2368         {
2369                 case 3:
2370                 {
2371                         if (driver.info_3 == NULL)
2372                                 result=5;
2373                         else {
2374                                 info3=driver.info_3;
2375                         
2376                                 DEBUGADD(20,("version:[%d]\n",         info3->cversion));
2377                                 DEBUGADD(20,("name:[%s]\n",            info3->name));
2378                                 DEBUGADD(20,("environment:[%s]\n",     info3->environment));
2379                                 DEBUGADD(20,("driverpath:[%s]\n",      info3->driverpath));
2380                                 DEBUGADD(20,("datafile:[%s]\n",        info3->datafile));
2381                                 DEBUGADD(20,("configfile:[%s]\n",      info3->configfile));
2382                                 DEBUGADD(20,("helpfile:[%s]\n",        info3->helpfile));
2383                                 DEBUGADD(20,("monitorname:[%s]\n",     info3->monitorname));
2384                                 DEBUGADD(20,("defaultdatatype:[%s]\n", info3->defaultdatatype));
2385                                 
2386                                 for (i=0; info3->dependentfiles &&
2387                                           *info3->dependentfiles[i]; i++) {
2388                                         DEBUGADD(20,("dependentfile:[%s]\n",
2389                                                       info3->dependentfiles[i]));
2390                                 }
2391                                 result=0;
2392                         }
2393                         break;
2394                 }
2395                 default:
2396                         DEBUGADD(20,("dump_a_printer_driver: Level %u not implemented\n", (unsigned int)level));
2397                         result=1;
2398                         break;
2399         }
2400         
2401         return result;
2402 }
2403
2404 /****************************************************************************
2405 ****************************************************************************/
2406 int pack_devicemode(NT_DEVICEMODE *nt_devmode, uint8 *buf, int buflen)
2407 {
2408         int len = 0;
2409
2410         len += tdb_pack(buf+len, buflen-len, "p", nt_devmode);
2411
2412         if (!nt_devmode)
2413                 return len;
2414
2415         len += tdb_pack(buf+len, buflen-len, "ffwwwwwwwwwwwwwwwwwwddddddddddddddp",
2416                         nt_devmode->devicename,
2417                         nt_devmode->formname,
2418
2419                         nt_devmode->specversion,
2420                         nt_devmode->driverversion,
2421                         nt_devmode->size,
2422                         nt_devmode->driverextra,
2423                         nt_devmode->orientation,
2424                         nt_devmode->papersize,
2425                         nt_devmode->paperlength,
2426                         nt_devmode->paperwidth,
2427                         nt_devmode->scale,
2428                         nt_devmode->copies,
2429                         nt_devmode->defaultsource,
2430                         nt_devmode->printquality,
2431                         nt_devmode->color,
2432                         nt_devmode->duplex,
2433                         nt_devmode->yresolution,
2434                         nt_devmode->ttoption,
2435                         nt_devmode->collate,
2436                         nt_devmode->logpixels,
2437                         
2438                         nt_devmode->fields,
2439                         nt_devmode->bitsperpel,
2440                         nt_devmode->pelswidth,
2441                         nt_devmode->pelsheight,
2442                         nt_devmode->displayflags,
2443                         nt_devmode->displayfrequency,
2444                         nt_devmode->icmmethod,
2445                         nt_devmode->icmintent,
2446                         nt_devmode->mediatype,
2447                         nt_devmode->dithertype,
2448                         nt_devmode->reserved1,
2449                         nt_devmode->reserved2,
2450                         nt_devmode->panningwidth,
2451                         nt_devmode->panningheight,
2452                         nt_devmode->nt_dev_private);
2453
2454         if (nt_devmode->nt_dev_private) {
2455                 len += tdb_pack(buf+len, buflen-len, "B",
2456                                 nt_devmode->driverextra,
2457                                 nt_devmode->nt_dev_private);
2458         }
2459
2460         DEBUG(8,("Packed devicemode [%s]\n", nt_devmode->formname));
2461
2462         return len;
2463 }
2464
2465 /****************************************************************************
2466  Pack all values in all printer keys
2467  ***************************************************************************/
2468
2469 static int pack_values(NT_PRINTER_DATA *data, uint8 *buf, int buflen)
2470 {
2471         int             len = 0;
2472         int             i, j;
2473         REGISTRY_VALUE  *val;
2474         REGVAL_CTR      *val_ctr;
2475         char *path = NULL;
2476         int             num_values;
2477
2478         if ( !data )
2479                 return 0;
2480
2481         /* loop over all keys */
2482
2483         for ( i=0; i<data->num_keys; i++ ) {
2484                 val_ctr = data->keys[i].values;
2485                 num_values = regval_ctr_numvals( val_ctr );
2486
2487                 /* pack the keyname followed by a empty value */
2488
2489                 len += tdb_pack(buf+len, buflen-len, "pPdB",
2490                                 &data->keys[i].name,
2491                                 data->keys[i].name,
2492                                 REG_NONE,
2493                                 0,
2494                                 NULL);
2495
2496                 /* now loop over all values */
2497
2498                 for ( j=0; j<num_values; j++ ) {
2499                         /* pathname should be stored as <key>\<value> */
2500
2501                         val = regval_ctr_specific_value( val_ctr, j );
2502                         if (asprintf(&path, "%s\\%s",
2503                                         data->keys[i].name,
2504                                         regval_name(val)) < 0) {
2505                                 return -1;
2506                         }
2507
2508                         len += tdb_pack(buf+len, buflen-len, "pPdB",
2509                                         val,
2510                                         path,
2511                                         regval_type(val),
2512                                         regval_size(val),
2513                                         regval_data_p(val) );
2514
2515                         DEBUG(8,("specific: [%s], len: %d\n", regval_name(val), regval_size(val)));
2516                         SAFE_FREE(path);
2517                 }
2518
2519         }
2520
2521         /* terminator */
2522
2523         len += tdb_pack(buf+len, buflen-len, "p", NULL);
2524
2525         return len;
2526 }
2527
2528
2529 /****************************************************************************
2530  Delete a printer - this just deletes the printer info file, any open
2531  handles are not affected.
2532 ****************************************************************************/
2533
2534 uint32 del_a_printer(const char *sharename)
2535 {
2536         TDB_DATA kbuf;
2537         char *printdb_path = NULL;
2538         TALLOC_CTX *ctx = talloc_tos();
2539
2540         kbuf = make_printer_tdbkey(ctx, sharename);
2541         tdb_delete(tdb_printers, kbuf);
2542
2543         kbuf= make_printers_secdesc_tdbkey(ctx, sharename);
2544         tdb_delete(tdb_printers, kbuf);
2545
2546         close_all_print_db();
2547
2548         if (geteuid() == 0) {
2549                 if (asprintf(&printdb_path, "%s%s.tdb",
2550                                 lock_path("printing/"),
2551                                 sharename) < 0) {
2552                         return (uint32)-1;
2553                 }
2554                 unlink(printdb_path);
2555                 SAFE_FREE(printdb_path);
2556         }
2557
2558         return 0;
2559 }
2560
2561 /****************************************************************************
2562 ****************************************************************************/
2563 static WERROR update_a_printer_2(NT_PRINTER_INFO_LEVEL_2 *info)
2564 {
2565         uint8 *buf;
2566         int buflen, len;
2567         int retlen;
2568         WERROR ret;
2569         TDB_DATA kbuf, dbuf;
2570         
2571         /*
2572          * in addprinter: no servername and the printer is the name
2573          * in setprinter: servername is \\server
2574          *                and printer is \\server\\printer
2575          *
2576          * Samba manages only local printers.
2577          * we currently don't support things like i
2578          * path=\\other_server\printer
2579          *
2580          * We only store the printername, not \\server\printername
2581          */
2582
2583         if ( info->servername[0] != '\0' ) {
2584                 trim_string(info->printername, info->servername, NULL);
2585                 trim_char(info->printername, '\\', '\0');
2586                 info->servername[0]='\0';
2587         }
2588
2589         /*
2590          * JFM: one day I'll forget.
2591          * below that's info->portname because that's the SAMBA sharename
2592          * and I made NT 'thinks' it's the portname
2593          * the info->sharename is the thing you can name when you add a printer
2594          * that's the short-name when you create shared printer for 95/98
2595          * So I've made a limitation in SAMBA: you can only have 1 printer model
2596          * behind a SAMBA share.
2597          */
2598
2599         buf = NULL;
2600         buflen = 0;
2601
2602  again:
2603         len = 0;
2604         len += tdb_pack(buf+len, buflen-len, "dddddddddddfffffPfffff",
2605                         info->attributes,
2606                         info->priority,
2607                         info->default_priority,
2608                         info->starttime,
2609                         info->untiltime,
2610                         info->status,
2611                         info->cjobs,
2612                         info->averageppm,
2613                         info->changeid,
2614                         info->c_setprinter,
2615                         info->setuptime,
2616                         info->servername,
2617                         info->printername,
2618                         info->sharename,
2619                         info->portname,
2620                         info->drivername,
2621                         info->comment,
2622                         info->location,
2623                         info->sepfile,
2624                         info->printprocessor,
2625                         info->datatype,
2626                         info->parameters);
2627
2628         len += pack_devicemode(info->devmode, buf+len, buflen-len);
2629         retlen = pack_values( info->data, buf+len, buflen-len );
2630         if (retlen == -1) {
2631                 ret = WERR_NOMEM;
2632                 goto done;
2633         }
2634         len += retlen;
2635
2636         if (buflen != len) {
2637                 buf = (uint8 *)SMB_REALLOC(buf, len);
2638                 if (!buf) {
2639                         DEBUG(0,("update_a_printer_2: failed to enlarge buffer!\n"));
2640                         ret = WERR_NOMEM;
2641                         goto done;
2642                 }
2643                 buflen = len;
2644                 goto again;
2645         }
2646
2647         kbuf = make_printer_tdbkey(talloc_tos(), info->sharename );
2648
2649         dbuf.dptr = buf;
2650         dbuf.dsize = len;
2651
2652         ret = (tdb_store(tdb_printers, kbuf, dbuf, TDB_REPLACE) == 0? WERR_OK : WERR_NOMEM);
2653
2654 done:
2655         if (!W_ERROR_IS_OK(ret))
2656                 DEBUG(8, ("error updating printer to tdb on disk\n"));
2657
2658         SAFE_FREE(buf);
2659
2660         DEBUG(8,("packed printer [%s] with driver [%s] portname=[%s] len=%d\n",
2661                  info->sharename, info->drivername, info->portname, len));
2662
2663         return ret;
2664 }
2665
2666
2667 /****************************************************************************
2668  Malloc and return an NT devicemode.
2669 ****************************************************************************/
2670
2671 NT_DEVICEMODE *construct_nt_devicemode(const fstring default_devicename)
2672 {
2673
2674         char adevice[MAXDEVICENAME];
2675         NT_DEVICEMODE *nt_devmode = SMB_MALLOC_P(NT_DEVICEMODE);
2676
2677         if (nt_devmode == NULL) {
2678                 DEBUG(0,("construct_nt_devicemode: malloc fail.\n"));
2679                 return NULL;
2680         }
2681
2682         ZERO_STRUCTP(nt_devmode);
2683
2684         slprintf(adevice, sizeof(adevice), "%s", default_devicename);
2685         fstrcpy(nt_devmode->devicename, adevice);       
2686         
2687         fstrcpy(nt_devmode->formname, "Letter");
2688
2689         nt_devmode->specversion      = 0x0401;
2690         nt_devmode->driverversion    = 0x0400;
2691         nt_devmode->size             = 0x00DC;
2692         nt_devmode->driverextra      = 0x0000;
2693         nt_devmode->fields           = FORMNAME | TTOPTION | PRINTQUALITY |
2694                                        DEFAULTSOURCE | COPIES | SCALE |
2695                                        PAPERSIZE | ORIENTATION;
2696         nt_devmode->orientation      = 1;
2697         nt_devmode->papersize        = PAPER_LETTER;
2698         nt_devmode->paperlength      = 0;
2699         nt_devmode->paperwidth       = 0;
2700         nt_devmode->scale            = 0x64;
2701         nt_devmode->copies           = 1;
2702         nt_devmode->defaultsource    = BIN_FORMSOURCE;
2703         nt_devmode->printquality     = RES_HIGH;           /* 0x0258 */
2704         nt_devmode->color            = COLOR_MONOCHROME;
2705         nt_devmode->duplex           = DUP_SIMPLEX;
2706         nt_devmode->yresolution      = 0;
2707         nt_devmode->ttoption         = TT_SUBDEV;
2708         nt_devmode->collate          = COLLATE_FALSE;
2709         nt_devmode->icmmethod        = 0;
2710         nt_devmode->icmintent        = 0;
2711         nt_devmode->mediatype        = 0;
2712         nt_devmode->dithertype       = 0;
2713
2714         /* non utilisés par un driver d'imprimante */
2715         nt_devmode->logpixels        = 0;
2716         nt_devmode->bitsperpel       = 0;
2717         nt_devmode->pelswidth        = 0;
2718         nt_devmode->pelsheight       = 0;
2719         nt_devmode->displayflags     = 0;
2720         nt_devmode->displayfrequency = 0;
2721         nt_devmode->reserved1        = 0;
2722         nt_devmode->reserved2        = 0;
2723         nt_devmode->panningwidth     = 0;
2724         nt_devmode->panningheight    = 0;
2725         
2726         nt_devmode->nt_dev_private = NULL;
2727         return nt_devmode;
2728 }
2729
2730 /****************************************************************************
2731  Deepcopy an NT devicemode.
2732 ****************************************************************************/
2733
2734 NT_DEVICEMODE *dup_nt_devicemode(NT_DEVICEMODE *nt_devicemode)
2735 {
2736         NT_DEVICEMODE *new_nt_devicemode = NULL;
2737
2738         if ( !nt_devicemode )
2739                 return NULL;
2740
2741         if ((new_nt_devicemode = (NT_DEVICEMODE *)memdup(nt_devicemode, sizeof(NT_DEVICEMODE))) == NULL) {
2742                 DEBUG(0,("dup_nt_devicemode: malloc fail.\n"));
2743                 return NULL;
2744         }
2745
2746         new_nt_devicemode->nt_dev_private = NULL;
2747         if (nt_devicemode->nt_dev_private != NULL) {
2748                 if ((new_nt_devicemode->nt_dev_private = (uint8 *)memdup(nt_devicemode->nt_dev_private, nt_devicemode->driverextra)) == NULL) {
2749                         SAFE_FREE(new_nt_devicemode);
2750                         DEBUG(0,("dup_nt_devicemode: malloc fail.\n"));
2751                         return NULL;
2752         }
2753         }
2754
2755         return new_nt_devicemode;
2756 }
2757
2758 /****************************************************************************
2759  Clean up and deallocate a (maybe partially) allocated NT_DEVICEMODE.
2760 ****************************************************************************/
2761
2762 void free_nt_devicemode(NT_DEVICEMODE **devmode_ptr)
2763 {
2764         NT_DEVICEMODE *nt_devmode = *devmode_ptr;
2765
2766         if(nt_devmode == NULL)
2767                 return;
2768
2769         DEBUG(106,("free_nt_devicemode: deleting DEVMODE\n"));
2770
2771         SAFE_FREE(nt_devmode->nt_dev_private);
2772         SAFE_FREE(*devmode_ptr);
2773 }
2774
2775 /****************************************************************************
2776  Clean up and deallocate a (maybe partially) allocated NT_PRINTER_INFO_LEVEL_2.
2777 ****************************************************************************/
2778
2779 static void free_nt_printer_info_level_2(NT_PRINTER_INFO_LEVEL_2 **info_ptr)
2780 {
2781         NT_PRINTER_INFO_LEVEL_2 *info = *info_ptr;
2782
2783         if ( !info )
2784                 return;
2785
2786         free_nt_devicemode(&info->devmode);
2787
2788         TALLOC_FREE( *info_ptr );
2789 }
2790
2791
2792 /****************************************************************************
2793 ****************************************************************************/
2794 int unpack_devicemode(NT_DEVICEMODE **nt_devmode, const uint8 *buf, int buflen)
2795 {
2796         int len = 0;
2797         int extra_len = 0;
2798         NT_DEVICEMODE devmode;
2799         
2800         ZERO_STRUCT(devmode);
2801
2802         len += tdb_unpack(buf+len, buflen-len, "p", nt_devmode);
2803
2804         if (!*nt_devmode) return len;
2805
2806         len += tdb_unpack(buf+len, buflen-len, "ffwwwwwwwwwwwwwwwwwwddddddddddddddp",
2807                           devmode.devicename,
2808                           devmode.formname,
2809
2810                           &devmode.specversion,
2811                           &devmode.driverversion,
2812                           &devmode.size,
2813                           &devmode.driverextra,
2814                           &devmode.orientation,
2815                           &devmode.papersize,
2816                           &devmode.paperlength,
2817                           &devmode.paperwidth,
2818                           &devmode.scale,
2819                           &devmode.copies,
2820                           &devmode.defaultsource,
2821                           &devmode.printquality,
2822                           &devmode.color,
2823                           &devmode.duplex,
2824                           &devmode.yresolution,
2825                           &devmode.ttoption,
2826                           &devmode.collate,
2827                           &devmode.logpixels,
2828                         
2829                           &devmode.fields,
2830                           &devmode.bitsperpel,
2831                           &devmode.pelswidth,
2832                           &devmode.pelsheight,
2833                           &devmode.displayflags,
2834                           &devmode.displayfrequency,
2835                           &devmode.icmmethod,
2836                           &devmode.icmintent,
2837                           &devmode.mediatype,
2838                           &devmode.dithertype,
2839                           &devmode.reserved1,
2840                           &devmode.reserved2,
2841                           &devmode.panningwidth,
2842                           &devmode.panningheight,
2843                           &devmode.nt_dev_private);
2844         
2845         if (devmode.nt_dev_private) {
2846                 /* the len in tdb_unpack is an int value and
2847                  * devmode.driverextra is only a short
2848                  */
2849                 len += tdb_unpack(buf+len, buflen-len, "B", &extra_len, &devmode.nt_dev_private);
2850                 devmode.driverextra=(uint16)extra_len;
2851                 
2852                 /* check to catch an invalid TDB entry so we don't segfault */
2853                 if (devmode.driverextra == 0) {
2854                         devmode.nt_dev_private = NULL;
2855                 }
2856         }
2857
2858         *nt_devmode = (NT_DEVICEMODE *)memdup(&devmode, sizeof(devmode));
2859         if (!*nt_devmode) {
2860                 SAFE_FREE(devmode.nt_dev_private);
2861                 return -1;
2862         }
2863
2864         DEBUG(8,("Unpacked devicemode [%s](%s)\n", devmode.devicename, devmode.formname));
2865         if (devmode.nt_dev_private)
2866                 DEBUG(8,("with a private section of %d bytes\n", devmode.driverextra));
2867
2868         return len;
2869 }
2870
2871 /****************************************************************************
2872  Allocate and initialize a new slot.
2873 ***************************************************************************/
2874  
2875 int add_new_printer_key( NT_PRINTER_DATA *data, const char *name )
2876 {
2877         NT_PRINTER_KEY  *d;
2878         int             key_index;
2879         
2880         if ( !name || !data )
2881                 return -1;
2882
2883         /* allocate another slot in the NT_PRINTER_KEY array */
2884         
2885         if ( !(d = TALLOC_REALLOC_ARRAY( data, data->keys, NT_PRINTER_KEY, data->num_keys+1)) ) {
2886                 DEBUG(0,("add_new_printer_key: Realloc() failed!\n"));
2887                 return -1;
2888         }
2889
2890         data->keys = d;
2891         
2892         key_index = data->num_keys;
2893         
2894         /* initialze new key */
2895         
2896         data->keys[key_index].name = talloc_strdup( data, name );
2897         
2898         if ( !(data->keys[key_index].values = TALLOC_ZERO_P( data, REGVAL_CTR )) ) 
2899                 return -1;
2900         
2901         data->num_keys++;
2902
2903         DEBUG(10,("add_new_printer_key: Inserted new data key [%s]\n", name ));
2904         
2905         return key_index;
2906 }
2907
2908 /****************************************************************************
2909  search for a registry key name in the existing printer data
2910  ***************************************************************************/
2911
2912 int delete_printer_key( NT_PRINTER_DATA *data, const char *name )
2913 {
2914         int i;
2915         
2916         for ( i=0; i<data->num_keys; i++ ) {
2917                 if ( strequal( data->keys[i].name, name ) ) {
2918                 
2919                         /* cleanup memory */
2920                         
2921                         TALLOC_FREE( data->keys[i].name );
2922                         TALLOC_FREE( data->keys[i].values );
2923                         
2924                         /* if not the end of the array, move remaining elements down one slot */
2925                         
2926                         data->num_keys--;
2927                         if ( data->num_keys && (i < data->num_keys) )
2928                                 memmove( &data->keys[i], &data->keys[i+1], sizeof(NT_PRINTER_KEY)*(data->num_keys-i) );
2929                                 
2930                         break;
2931                 }
2932         }
2933         
2934
2935         return data->num_keys;
2936 }
2937
2938 /****************************************************************************
2939  search for a registry key name in the existing printer data
2940  ***************************************************************************/
2941  
2942 int lookup_printerkey( NT_PRINTER_DATA *data, const char *name )
2943 {
2944         int             key_index = -1;
2945         int             i;
2946         
2947         if ( !data || !name )
2948                 return -1;
2949
2950         DEBUG(12,("lookup_printerkey: Looking for [%s]\n", name));
2951
2952         /* loop over all existing keys */
2953         
2954         for ( i=0; i<data->num_keys; i++ ) {
2955                 if ( strequal(data->keys[i].name, name) ) {
2956                         DEBUG(12,("lookup_printerkey: Found [%s]!\n", name));
2957                         key_index = i;
2958                         break;
2959                 
2960                 }
2961         }
2962         
2963         return key_index;
2964 }
2965
2966 /****************************************************************************
2967  ***************************************************************************/
2968
2969 int get_printer_subkeys( NT_PRINTER_DATA *data, const char* key, fstring **subkeys )
2970 {
2971         int     i, j;
2972         int     key_len;
2973         int     num_subkeys = 0;
2974         char    *p;
2975         fstring *subkeys_ptr = NULL;
2976         fstring subkeyname;
2977         
2978         *subkeys = NULL;
2979
2980         if ( !data )
2981                 return 0;
2982
2983         if ( !key )
2984                 return -1;
2985
2986         /* special case of asking for the top level printer data registry key names */
2987
2988         if ( strlen(key) == 0 ) {
2989                 for ( i=0; i<data->num_keys; i++ ) {
2990                 
2991                         /* found a match, so allocate space and copy the name */
2992                         
2993                         if ( !(subkeys_ptr = SMB_REALLOC_ARRAY( subkeys_ptr, fstring, num_subkeys+2)) ) {
2994                                 DEBUG(0,("get_printer_subkeys: Realloc failed for [%d] entries!\n", 
2995                                         num_subkeys+1));
2996                                 return -1;
2997                         }
2998                         
2999                         fstrcpy( subkeys_ptr[num_subkeys], data->keys[i].name );
3000                         num_subkeys++;
3001                 }
3002
3003                 goto done;
3004         }
3005                 
3006         /* asking for the subkeys of some key */
3007         /* subkey paths are stored in the key name using '\' as the delimiter */
3008
3009         for ( i=0; i<data->num_keys; i++ ) {
3010                 if ( StrnCaseCmp(data->keys[i].name, key, strlen(key)) == 0 ) {
3011                         
3012                         /* if we found the exact key, then break */
3013                         key_len = strlen( key );
3014                         if ( strlen(data->keys[i].name) == key_len )
3015                                 break;
3016                         
3017                         /* get subkey path */
3018
3019                         p = data->keys[i].name + key_len;
3020                         if ( *p == '\\' )
3021                                 p++;
3022                         fstrcpy( subkeyname, p );
3023                         if ( (p = strchr( subkeyname, '\\' )) )
3024                                 *p = '\0';
3025                         
3026                         /* don't add a key more than once */
3027                         
3028                         for ( j=0; j<num_subkeys; j++ ) {
3029                                 if ( strequal( subkeys_ptr[j], subkeyname ) )
3030                                         break;
3031                         }
3032                         
3033                         if ( j != num_subkeys )
3034                                 continue;
3035
3036                         /* found a match, so allocate space and copy the name */
3037                         
3038                         if ( !(subkeys_ptr = SMB_REALLOC_ARRAY( subkeys_ptr, fstring, num_subkeys+2)) ) {
3039                                 DEBUG(0,("get_printer_subkeys: Realloc failed for [%d] entries!\n", 
3040                                         num_subkeys+1));
3041                                 return 0;
3042                         }
3043                         
3044                         fstrcpy( subkeys_ptr[num_subkeys], subkeyname );
3045                         num_subkeys++;
3046                 }
3047                 
3048         }
3049         
3050         /* return error if the key was not found */
3051         
3052         if ( i == data->num_keys ) {
3053                 SAFE_FREE(subkeys_ptr);
3054                 return -1;
3055         }
3056         
3057 done:
3058         /* tag off the end */
3059         
3060         if (num_subkeys)
3061                 fstrcpy(subkeys_ptr[num_subkeys], "" );
3062         
3063         *subkeys = subkeys_ptr;
3064
3065         return num_subkeys;
3066 }
3067
3068 #ifdef HAVE_ADS
3069 static void map_sz_into_ctr(REGVAL_CTR *ctr, const char *val_name, 
3070                             const char *sz)
3071 {
3072         smb_ucs2_t conv_str[1024];
3073         size_t str_size;
3074
3075         regval_ctr_delvalue(ctr, val_name);
3076         str_size = push_ucs2(NULL, conv_str, sz, sizeof(conv_str),
3077                              STR_TERMINATE | STR_NOALIGN);
3078         regval_ctr_addvalue(ctr, val_name, REG_SZ, 
3079                             (char *) conv_str, str_size);
3080 }
3081
3082 static void map_dword_into_ctr(REGVAL_CTR *ctr, const char *val_name, 
3083                                uint32 dword)
3084 {
3085         regval_ctr_delvalue(ctr, val_name);
3086         regval_ctr_addvalue(ctr, val_name, REG_DWORD,
3087                             (char *) &dword, sizeof(dword));
3088 }
3089
3090 static void map_bool_into_ctr(REGVAL_CTR *ctr, const char *val_name,
3091                               bool b)
3092 {
3093         uint8 bin_bool = (b ? 1 : 0);
3094         regval_ctr_delvalue(ctr, val_name);
3095         regval_ctr_addvalue(ctr, val_name, REG_BINARY, 
3096                             (char *) &bin_bool, sizeof(bin_bool));
3097 }
3098
3099 static void map_single_multi_sz_into_ctr(REGVAL_CTR *ctr, const char *val_name,
3100                                          const char *multi_sz)
3101 {
3102         smb_ucs2_t *conv_strs = NULL;
3103         size_t str_size;
3104
3105         /* a multi-sz has to have a null string terminator, i.e., the last
3106            string must be followed by two nulls */
3107         str_size = strlen(multi_sz) + 2;
3108         conv_strs = SMB_CALLOC_ARRAY(smb_ucs2_t, str_size);
3109         if (!conv_strs) {
3110                 return;
3111         }
3112
3113         /* Change to byte units. */
3114         str_size *= sizeof(smb_ucs2_t);
3115         push_ucs2(NULL, conv_strs, multi_sz, str_size, 
3116                   STR_TERMINATE | STR_NOALIGN);
3117
3118         regval_ctr_delvalue(ctr, val_name);
3119         regval_ctr_addvalue(ctr, val_name, REG_MULTI_SZ, 
3120                             (char *) conv_strs, str_size);      
3121         SAFE_FREE(conv_strs);
3122 }
3123
3124 /****************************************************************************
3125  * Map the NT_PRINTER_INFO_LEVEL_2 data into DsSpooler keys for publishing.
3126  *
3127  * @param info2 NT_PRINTER_INFO_LEVEL_2 describing printer - gets modified
3128  * @return bool indicating success or failure
3129  ***************************************************************************/
3130
3131 static bool map_nt_printer_info2_to_dsspooler(NT_PRINTER_INFO_LEVEL_2 *info2)
3132 {
3133         REGVAL_CTR *ctr = NULL;
3134         fstring longname;
3135         const char *dnssuffix;
3136         char *allocated_string = NULL;
3137         const char *ascii_str;
3138         int i;
3139
3140         if ((i = lookup_printerkey(info2->data, SPOOL_DSSPOOLER_KEY)) < 0)
3141                 i = add_new_printer_key(info2->data, SPOOL_DSSPOOLER_KEY);
3142         ctr = info2->data->keys[i].values;
3143
3144         map_sz_into_ctr(ctr, SPOOL_REG_PRINTERNAME, info2->sharename);
3145         map_sz_into_ctr(ctr, SPOOL_REG_SHORTSERVERNAME, global_myname());
3146
3147         /* we make the assumption that the netbios name is the same
3148            as the DNS name sinc ethe former will be what we used to
3149            join the domain */
3150
3151         dnssuffix = get_mydnsdomname(talloc_tos());
3152         if (dnssuffix && *dnssuffix) {
3153                 fstr_sprintf( longname, "%s.%s", global_myname(), dnssuffix );
3154         } else {
3155                 fstrcpy( longname, global_myname() );
3156         }
3157
3158         map_sz_into_ctr(ctr, SPOOL_REG_SERVERNAME, longname);
3159
3160         asprintf(&allocated_string, "\\\\%s\\%s", longname, info2->sharename);
3161         map_sz_into_ctr(ctr, SPOOL_REG_UNCNAME, allocated_string);
3162         SAFE_FREE(allocated_string);
3163
3164         map_dword_into_ctr(ctr, SPOOL_REG_VERSIONNUMBER, 4);
3165         map_sz_into_ctr(ctr, SPOOL_REG_DRIVERNAME, info2->drivername);
3166         map_sz_into_ctr(ctr, SPOOL_REG_LOCATION, info2->location);
3167         map_sz_into_ctr(ctr, SPOOL_REG_DESCRIPTION, info2->comment);
3168         map_single_multi_sz_into_ctr(ctr, SPOOL_REG_PORTNAME, info2->portname);
3169         map_sz_into_ctr(ctr, SPOOL_REG_PRINTSEPARATORFILE, info2->sepfile);
3170         map_dword_into_ctr(ctr, SPOOL_REG_PRINTSTARTTIME, info2->starttime);
3171         map_dword_into_ctr(ctr, SPOOL_REG_PRINTENDTIME, info2->untiltime);
3172         map_dword_into_ctr(ctr, SPOOL_REG_PRIORITY, info2->priority);
3173
3174         map_bool_into_ctr(ctr, SPOOL_REG_PRINTKEEPPRINTEDJOBS,
3175                           (info2->attributes & 
3176                            PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS));
3177
3178         switch (info2->attributes & 0x3) {
3179         case 0:
3180                 ascii_str = SPOOL_REGVAL_PRINTWHILESPOOLING;
3181                 break;
3182         case 1:
3183                 ascii_str = SPOOL_REGVAL_PRINTAFTERSPOOLED;
3184                 break;
3185         case 2:
3186                 ascii_str = SPOOL_REGVAL_PRINTDIRECT;
3187                 break;
3188         default:
3189                 ascii_str = "unknown";
3190         }
3191         map_sz_into_ctr(ctr, SPOOL_REG_PRINTSPOOLING, ascii_str);
3192
3193         return True;
3194 }
3195
3196 /*****************************************************************
3197  ****************************************************************/
3198
3199 static void store_printer_guid(NT_PRINTER_INFO_LEVEL_2 *info2, 
3200                                struct GUID guid)
3201 {
3202         int i;
3203         REGVAL_CTR *ctr=NULL;
3204         UNISTR2 unistr_guid;
3205
3206         /* find the DsSpooler key */
3207         if ((i = lookup_printerkey(info2->data, SPOOL_DSSPOOLER_KEY)) < 0)
3208                 i = add_new_printer_key(info2->data, SPOOL_DSSPOOLER_KEY);
3209         ctr = info2->data->keys[i].values;
3210
3211         regval_ctr_delvalue(ctr, "objectGUID");
3212
3213         /* We used to store this as a REG_BINARY but that causes
3214            Vista to whine */
3215
3216         ZERO_STRUCT( unistr_guid );     
3217         
3218         init_unistr2( &unistr_guid, GUID_string(talloc_tos(), &guid),
3219                       UNI_STR_TERMINATE );
3220
3221         regval_ctr_addvalue(ctr, "objectGUID", REG_SZ, 
3222                             (char *)unistr_guid.buffer, 
3223                             unistr_guid.uni_max_len*2);
3224         
3225 }
3226
3227 static WERROR nt_printer_publish_ads(ADS_STRUCT *ads,
3228                                      NT_PRINTER_INFO_LEVEL *printer)
3229 {
3230         ADS_STATUS ads_rc;
3231         LDAPMessage *res;
3232         char *prt_dn = NULL, *srv_dn, *srv_cn_0, *srv_cn_escaped, *sharename_escaped;
3233         char *srv_dn_utf8, **srv_cn_utf8;
3234         TALLOC_CTX *ctx;
3235         ADS_MODLIST mods;
3236         const char *attrs[] = {"objectGUID", NULL};
3237         struct GUID guid;
3238         WERROR win_rc = WERR_OK;
3239         size_t converted_size;
3240
3241         DEBUG(5, ("publishing printer %s\n", printer->info_2->printername));
3242
3243         /* figure out where to publish */
3244         ads_find_machine_acct(ads, &res, global_myname());
3245
3246         /* We use ldap_get_dn here as we need the answer
3247          * in utf8 to call ldap_explode_dn(). JRA. */
3248
3249         srv_dn_utf8 = ldap_get_dn((LDAP *)ads->ldap.ld, (LDAPMessage *)res);
3250         if (!srv_dn_utf8) {
3251                 ads_destroy(&ads);
3252                 return WERR_SERVER_UNAVAILABLE;
3253         }
3254         ads_msgfree(ads, res);
3255         srv_cn_utf8 = ldap_explode_dn(srv_dn_utf8, 1);
3256         if (!srv_cn_utf8) {
3257                 ldap_memfree(srv_dn_utf8);
3258                 ads_destroy(&ads);
3259                 return WERR_SERVER_UNAVAILABLE;
3260         }
3261         /* Now convert to CH_UNIX. */
3262         if (!pull_utf8_allocate(&srv_dn, srv_dn_utf8, &converted_size)) {
3263                 ldap_memfree(srv_dn_utf8);
3264                 ldap_memfree(srv_cn_utf8);
3265                 ads_destroy(&ads);
3266                 return WERR_SERVER_UNAVAILABLE;
3267         }
3268         if (!pull_utf8_allocate(&srv_cn_0, srv_cn_utf8[0], &converted_size)) {
3269                 ldap_memfree(srv_dn_utf8);
3270                 ldap_memfree(srv_cn_utf8);
3271                 ads_destroy(&ads);
3272                 SAFE_FREE(srv_dn);
3273                 return WERR_SERVER_UNAVAILABLE;
3274         }
3275
3276         ldap_memfree(srv_dn_utf8);
3277         ldap_memfree(srv_cn_utf8);
3278
3279         srv_cn_escaped = escape_rdn_val_string_alloc(srv_cn_0);
3280         if (!srv_cn_escaped) {
3281                 SAFE_FREE(srv_cn_0);
3282                 ldap_memfree(srv_dn_utf8);
3283                 ads_destroy(&ads);
3284                 return WERR_SERVER_UNAVAILABLE;
3285         }
3286         sharename_escaped = escape_rdn_val_string_alloc(printer->info_2->sharename);
3287         if (!sharename_escaped) {
3288                 SAFE_FREE(srv_cn_escaped);
3289                 SAFE_FREE(srv_cn_0);
3290                 ldap_memfree(srv_dn_utf8);
3291                 ads_destroy(&ads);
3292                 return WERR_SERVER_UNAVAILABLE;
3293         }
3294
3295
3296         asprintf(&prt_dn, "cn=%s-%s,%s", srv_cn_escaped, sharename_escaped, srv_dn);
3297
3298         SAFE_FREE(srv_dn);
3299         SAFE_FREE(srv_cn_0);
3300         SAFE_FREE(srv_cn_escaped);
3301         SAFE_FREE(sharename_escaped);
3302
3303         /* build the ads mods */
3304         ctx = talloc_init("nt_printer_publish_ads");
3305         if (ctx == NULL) {
3306                 SAFE_FREE(prt_dn);
3307                 return WERR_NOMEM;
3308         }
3309
3310         mods = ads_init_mods(ctx);
3311
3312         if (mods == NULL) {
3313                 SAFE_FREE(prt_dn);
3314                 talloc_destroy(ctx);
3315                 return WERR_NOMEM;
3316         }
3317
3318         get_local_printer_publishing_data(ctx, &mods, printer->info_2->data);
3319         ads_mod_str(ctx, &mods, SPOOL_REG_PRINTERNAME, 
3320                     printer->info_2->sharename);
3321
3322         /* publish it */
3323         ads_rc = ads_mod_printer_entry(ads, prt_dn, ctx, &mods);
3324         if (ads_rc.err.rc == LDAP_NO_SUCH_OBJECT) {
3325                 int i;
3326                 for (i=0; mods[i] != 0; i++)
3327                         ;
3328                 mods[i] = (LDAPMod *)-1;
3329                 ads_rc = ads_add_printer_entry(ads, prt_dn, ctx, &mods);
3330         }
3331
3332         if (!ADS_ERR_OK(ads_rc))
3333                 DEBUG(3, ("error publishing %s: %s\n", printer->info_2->sharename, ads_errstr(ads_rc)));
3334         
3335         talloc_destroy(ctx);
3336
3337         /* retreive the guid and store it locally */
3338         if (ADS_ERR_OK(ads_search_dn(ads, &res, prt_dn, attrs))) {
3339                 ZERO_STRUCT(guid);
3340                 ads_pull_guid(ads, res, &guid);
3341                 ads_msgfree(ads, res);
3342                 store_printer_guid(printer->info_2, guid);
3343                 win_rc = mod_a_printer(printer, 2);
3344         } 
3345
3346         SAFE_FREE(prt_dn);
3347         return win_rc;
3348 }
3349
3350 static WERROR nt_printer_unpublish_ads(ADS_STRUCT *ads,
3351                                        NT_PRINTER_INFO_LEVEL *printer)
3352 {
3353         ADS_STATUS ads_rc;
3354         LDAPMessage *res;
3355         char *prt_dn = NULL;
3356
3357         DEBUG(5, ("unpublishing printer %s\n", printer->info_2->printername));
3358
3359         /* remove the printer from the directory */
3360         ads_rc = ads_find_printer_on_server(ads, &res, 
3361                             printer->info_2->sharename, global_myname());
3362
3363         if (ADS_ERR_OK(ads_rc) && ads_count_replies(ads, res)) {
3364                 prt_dn = ads_get_dn(ads, res);
3365                 if (!prt_dn) {
3366                         ads_msgfree(ads, res);
3367                         return WERR_NOMEM;
3368                 }
3369                 ads_rc = ads_del_dn(ads, prt_dn);
3370                 ads_memfree(ads, prt_dn);
3371         }
3372
3373         ads_msgfree(ads, res);
3374         return WERR_OK;
3375 }
3376
3377 /****************************************************************************
3378  * Publish a printer in the directory
3379  *
3380  * @param snum describing printer service
3381  * @return WERROR indicating status of publishing
3382  ***************************************************************************/
3383
3384 WERROR nt_printer_publish(Printer_entry *print_hnd, int snum, int action)
3385 {
3386         ADS_STATUS ads_rc;
3387         ADS_STRUCT *ads = NULL;
3388         NT_PRINTER_INFO_LEVEL *printer = NULL;
3389         WERROR win_rc;
3390
3391         win_rc = get_a_printer(print_hnd, &printer, 2, lp_servicename(snum));
3392         if (!W_ERROR_IS_OK(win_rc))
3393                 goto done;
3394
3395         switch (action) {
3396         case SPOOL_DS_PUBLISH:
3397         case SPOOL_DS_UPDATE:
3398                 /* set the DsSpooler info and attributes */
3399                 if (!(map_nt_printer_info2_to_dsspooler(printer->info_2))) {
3400                         win_rc = WERR_NOMEM;
3401                         goto done;
3402                 }
3403
3404                 printer->info_2->attributes |= PRINTER_ATTRIBUTE_PUBLISHED;
3405                 break;
3406         case SPOOL_DS_UNPUBLISH:
3407                 printer->info_2->attributes ^= PRINTER_ATTRIBUTE_PUBLISHED;
3408                 break;
3409         default:
3410                 win_rc = WERR_NOT_SUPPORTED;
3411                 goto done;
3412         }
3413
3414         win_rc = mod_a_printer(printer, 2);
3415         if (!W_ERROR_IS_OK(win_rc)) {
3416                 DEBUG(3, ("err %d saving data\n", W_ERROR_V(win_rc)));
3417                 goto done;
3418         }
3419
3420         ads = ads_init(lp_realm(), lp_workgroup(), NULL);
3421         if (!ads) {
3422                 DEBUG(3, ("ads_init() failed\n"));
3423                 win_rc = WERR_SERVER_UNAVAILABLE;
3424                 goto done;
3425         }
3426         setenv(KRB5_ENV_CCNAME, "MEMORY:prtpub_cache", 1);
3427         SAFE_FREE(ads->auth.password);
3428         ads->auth.password = secrets_fetch_machine_password(lp_workgroup(),
3429                 NULL, NULL);
3430
3431         /* ads_connect() will find the DC for us */                                         
3432         ads_rc = ads_connect(ads);
3433         if (!ADS_ERR_OK(ads_rc)) {
3434                 DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_rc)));
3435                 win_rc = WERR_ACCESS_DENIED;
3436                 goto done;
3437         }
3438
3439         switch (action) {
3440         case SPOOL_DS_PUBLISH:
3441         case SPOOL_DS_UPDATE:
3442                 win_rc = nt_printer_publish_ads(ads, printer);
3443                 break;
3444         case SPOOL_DS_UNPUBLISH:
3445                 win_rc = nt_printer_unpublish_ads(ads, printer);
3446                 break;
3447         }
3448
3449 done:
3450         free_a_printer(&printer, 2);
3451         ads_destroy(&ads);
3452         return win_rc;
3453 }
3454
3455 WERROR check_published_printers(void)
3456 {
3457         ADS_STATUS ads_rc;
3458         ADS_STRUCT *ads = NULL;
3459         int snum;
3460         int n_services = lp_numservices();
3461         NT_PRINTER_INFO_LEVEL *printer = NULL;
3462
3463         ads = ads_init(lp_realm(), lp_workgroup(), NULL);
3464         if (!ads) {
3465                 DEBUG(3, ("ads_init() failed\n"));
3466                 return WERR_SERVER_UNAVAILABLE;
3467         }
3468         setenv(KRB5_ENV_CCNAME, "MEMORY:prtpub_cache", 1);
3469         SAFE_FREE(ads->auth.password);
3470         ads->auth.password = secrets_fetch_machine_password(lp_workgroup(),
3471                 NULL, NULL);
3472
3473         /* ads_connect() will find the DC for us */                                         
3474         ads_rc = ads_connect(ads);
3475         if (!ADS_ERR_OK(ads_rc)) {
3476                 DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_rc)));
3477                 ads_destroy(&ads);
3478                 ads_kdestroy("MEMORY:prtpub_cache");
3479                 return WERR_ACCESS_DENIED;
3480         }
3481
3482         for (snum = 0; snum < n_services; snum++) {
3483                 if (!(lp_snum_ok(snum) && lp_print_ok(snum)))
3484                         continue;
3485
3486                 if (W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2,
3487                                                 lp_servicename(snum))) &&
3488                     (printer->info_2->attributes & PRINTER_ATTRIBUTE_PUBLISHED))
3489                         nt_printer_publish_ads(ads, printer);
3490
3491                 free_a_printer(&printer, 2);
3492         }
3493
3494         ads_destroy(&ads);
3495         ads_kdestroy("MEMORY:prtpub_cache");
3496         return WERR_OK;
3497 }
3498
3499 bool is_printer_published(Printer_entry *print_hnd, int snum, 
3500                           struct GUID *guid)
3501 {
3502         NT_PRINTER_INFO_LEVEL *printer = NULL;
3503         REGVAL_CTR *ctr;
3504         REGISTRY_VALUE *guid_val;
3505         WERROR win_rc;
3506         int i;
3507         bool ret = False;
3508
3509         win_rc = get_a_printer(print_hnd, &printer, 2, lp_servicename(snum));
3510
3511         if (!W_ERROR_IS_OK(win_rc) ||
3512             !(printer->info_2->attributes & PRINTER_ATTRIBUTE_PUBLISHED) ||
3513             ((i = lookup_printerkey(printer->info_2->data, SPOOL_DSSPOOLER_KEY)) < 0) ||
3514             !(ctr = printer->info_2->data->keys[i].values) ||
3515             !(guid_val = regval_ctr_getvalue(ctr, "objectGUID"))) 
3516         {
3517                 free_a_printer(&printer, 2);
3518                 return False;
3519         }
3520
3521         /* fetching printer guids really ought to be a separate function. */
3522
3523         if ( guid ) {   
3524                 fstring guid_str;
3525                 
3526                 /* We used to store the guid as REG_BINARY, then swapped 
3527                    to REG_SZ for Vista compatibility so check for both */
3528
3529                 switch ( regval_type(guid_val) ){
3530                 case REG_SZ:            
3531                         rpcstr_pull( guid_str, regval_data_p(guid_val), 
3532                                      sizeof(guid_str)-1, -1, STR_TERMINATE );
3533                         ret = NT_STATUS_IS_OK(GUID_from_string( guid_str, guid ));
3534                         break;                  
3535                 case REG_BINARY:
3536                         if ( regval_size(guid_val) != sizeof(struct GUID) ) {
3537                                 ret = False;
3538                                 break;
3539                         }
3540                         memcpy(guid, regval_data_p(guid_val), sizeof(struct GUID));
3541                         break;
3542                 default:
3543                         DEBUG(0,("is_printer_published: GUID value stored as "
3544                                  "invaluid type (%d)\n", regval_type(guid_val) ));                      
3545                         break;
3546                 }
3547         }
3548
3549         free_a_printer(&printer, 2);
3550         return ret;
3551 }
3552 #else
3553 WERROR nt_printer_publish(Printer_entry *print_hnd, int snum, int action)
3554 {
3555         return WERR_OK;
3556 }
3557
3558 WERROR check_published_printers(void)
3559 {
3560         return WERR_OK;
3561 }
3562
3563 bool is_printer_published(Printer_entry *print_hnd, int snum, 
3564                           struct GUID *guid)
3565 {
3566         return False;
3567 }
3568 #endif /* HAVE_ADS */
3569
3570 /****************************************************************************
3571  ***************************************************************************/
3572  
3573 WERROR delete_all_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key )
3574 {
3575         NT_PRINTER_DATA *data;
3576         int             i;
3577         int             removed_keys = 0;
3578         int             empty_slot;
3579         
3580         data = p2->data;
3581         empty_slot = data->num_keys;
3582
3583         if ( !key )
3584                 return WERR_INVALID_PARAM;
3585         
3586         /* remove all keys */
3587
3588         if ( !strlen(key) ) {
3589         
3590                 TALLOC_FREE( data );
3591
3592                 p2->data = NULL;
3593
3594                 DEBUG(8,("delete_all_printer_data: Removed all Printer Data from printer [%s]\n",
3595                         p2->printername ));
3596         
3597                 return WERR_OK;
3598         }
3599
3600         /* remove a specific key (and all subkeys) */
3601         
3602         for ( i=0; i<data->num_keys; i++ ) {
3603                 if ( StrnCaseCmp( data->keys[i].name, key, strlen(key)) == 0 ) {
3604                         DEBUG(8,("delete_all_printer_data: Removed all Printer Data from key [%s]\n",
3605                                 data->keys[i].name));
3606                 
3607                         TALLOC_FREE( data->keys[i].name );
3608                         TALLOC_FREE( data->keys[i].values );
3609
3610                         /* mark the slot as empty */
3611
3612                         ZERO_STRUCTP( &data->keys[i] );
3613                 }
3614         }
3615
3616         /* find the first empty slot */
3617
3618         for ( i=0; i<data->num_keys; i++ ) {
3619                 if ( !data->keys[i].name ) {
3620                         empty_slot = i;
3621                         removed_keys++;
3622                         break;
3623                 }
3624         }
3625
3626         if ( i == data->num_keys )
3627                 /* nothing was removed */
3628                 return WERR_INVALID_PARAM;
3629
3630         /* move everything down */
3631         
3632         for ( i=empty_slot+1; i<data->num_keys; i++ ) {
3633                 if ( data->keys[i].name ) {
3634                         memcpy( &data->keys[empty_slot], &data->keys[i], sizeof(NT_PRINTER_KEY) ); 
3635                         ZERO_STRUCTP( &data->keys[i] );
3636                         empty_slot++;
3637                         removed_keys++;
3638                 }
3639         }
3640
3641         /* update count */
3642                 
3643         data->num_keys -= removed_keys;
3644
3645         /* sanity check to see if anything is left */
3646
3647         if ( !data->num_keys ) {
3648                 DEBUG(8,("delete_all_printer_data: No keys left for printer [%s]\n", p2->printername ));
3649
3650                 SAFE_FREE( data->keys );
3651                 ZERO_STRUCTP( data );
3652         }
3653
3654         return WERR_OK;
3655 }
3656
3657 /****************************************************************************
3658  ***************************************************************************/
3659  
3660 WERROR delete_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value )
3661 {
3662         WERROR          result = WERR_OK;
3663         int             key_index;
3664         
3665         /* we must have names on non-zero length */
3666         
3667         if ( !key || !*key|| !value || !*value )
3668                 return WERR_INVALID_NAME;
3669                 
3670         /* find the printer key first */
3671
3672         key_index = lookup_printerkey( p2->data, key );
3673         if ( key_index == -1 )
3674                 return WERR_OK;
3675         
3676         /* make sure the value exists so we can return the correct error code */
3677         
3678         if ( !regval_ctr_getvalue( p2->data->keys[key_index].values, value ) )
3679                 return WERR_BADFILE;
3680                 
3681         regval_ctr_delvalue( p2->data->keys[key_index].values, value );
3682         
3683         DEBUG(8,("delete_printer_data: Removed key => [%s], value => [%s]\n",
3684                 key, value ));
3685         
3686         return result;
3687 }
36