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