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.
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.
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.
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/>.
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 */
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"
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 */
41 /* Map generic permissions to printer object specific permissions */
43 const struct generic_mapping printer_generic_mapping = {
50 const struct standard_mapping printer_std_mapping = {
57 /* Map generic permissions to print server object specific permissions */
59 const struct generic_mapping printserver_generic_mapping = {
66 const struct generic_mapping printserver_std_mapping = {
73 /* Map generic permissions to job object specific permissions */
75 const struct generic_mapping job_generic_mapping = {
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}
208 const char *long_archi;
209 const char *short_archi;
213 #define SPL_ARCH_WIN40 "WIN40"
214 #define SPL_ARCH_W32X86 "W32X86"
215 #define SPL_ARCH_W32MIPS "W32MIPS"
216 #define SPL_ARCH_W32ALPHA "W32ALPHA"
217 #define SPL_ARCH_W32PPC "W32PPC"
218 #define SPL_ARCH_IA64 "IA64"
219 #define SPL_ARCH_X64 "x64"
221 static const struct table_node archi_table[]= {
223 {"Windows 4.0", SPL_ARCH_WIN40, 0 },
224 {"Windows NT x86", SPL_ARCH_W32X86, 2 },
225 {"Windows NT R4000", SPL_ARCH_W32MIPS, 2 },
226 {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA, 2 },
227 {"Windows NT PowerPC", SPL_ARCH_W32PPC, 2 },
228 {"Windows IA64", SPL_ARCH_IA64, 3 },
229 {"Windows x64", SPL_ARCH_X64, 3 },
234 /****************************************************************************
235 generate a new TDB_DATA key for storing a printer
236 ****************************************************************************/
238 static TDB_DATA make_printer_tdbkey(TALLOC_CTX *ctx, const char *sharename )
244 fstrcpy(share, sharename);
247 keystr = talloc_asprintf(ctx, "%s%s", PRINTERS_PREFIX, share);
248 key = string_term_tdb_data(keystr ? keystr : "");
253 /****************************************************************************
254 generate a new TDB_DATA key for storing a printer security descriptor
255 ****************************************************************************/
257 static TDB_DATA make_printers_secdesc_tdbkey(TALLOC_CTX *ctx,
258 const char* sharename )
264 fstrcpy(share, sharename );
267 keystr = talloc_asprintf(ctx, "%s%s", SECDESC_PREFIX, share);
268 key = string_term_tdb_data(keystr ? keystr : "");
273 /****************************************************************************
274 ****************************************************************************/
276 static bool upgrade_to_version_3(void)
278 TDB_DATA kbuf, newkey, dbuf;
280 DEBUG(0,("upgrade_to_version_3: upgrading print tdb's to version 3\n"));
282 for (kbuf = tdb_firstkey(tdb_drivers); kbuf.dptr;
283 newkey = tdb_nextkey(tdb_drivers, kbuf), free(kbuf.dptr), kbuf=newkey) {
285 dbuf = tdb_fetch(tdb_drivers, kbuf);
287 if (strncmp((const char *)kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) == 0) {
288 DEBUG(0,("upgrade_to_version_3:moving form\n"));
289 if (tdb_store(tdb_forms, kbuf, dbuf, TDB_REPLACE) != 0) {
290 SAFE_FREE(dbuf.dptr);
291 DEBUG(0,("upgrade_to_version_3: failed to move form. Error (%s).\n", tdb_errorstr(tdb_forms)));
294 if (tdb_delete(tdb_drivers, kbuf) != 0) {
295 SAFE_FREE(dbuf.dptr);
296 DEBUG(0,("upgrade_to_version_3: failed to delete form. Error (%s)\n", tdb_errorstr(tdb_drivers)));
301 if (strncmp((const char *)kbuf.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX)) == 0) {
302 DEBUG(0,("upgrade_to_version_3:moving printer\n"));
303 if (tdb_store(tdb_printers, kbuf, dbuf, TDB_REPLACE) != 0) {
304 SAFE_FREE(dbuf.dptr);
305 DEBUG(0,("upgrade_to_version_3: failed to move printer. Error (%s)\n", tdb_errorstr(tdb_printers)));
308 if (tdb_delete(tdb_drivers, kbuf) != 0) {
309 SAFE_FREE(dbuf.dptr);
310 DEBUG(0,("upgrade_to_version_3: failed to delete printer. Error (%s)\n", tdb_errorstr(tdb_drivers)));
315 if (strncmp((const char *)kbuf.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX)) == 0) {
316 DEBUG(0,("upgrade_to_version_3:moving secdesc\n"));
317 if (tdb_store(tdb_printers, kbuf, dbuf, TDB_REPLACE) != 0) {
318 SAFE_FREE(dbuf.dptr);
319 DEBUG(0,("upgrade_to_version_3: failed to move secdesc. Error (%s)\n", tdb_errorstr(tdb_printers)));
322 if (tdb_delete(tdb_drivers, kbuf) != 0) {
323 SAFE_FREE(dbuf.dptr);
324 DEBUG(0,("upgrade_to_version_3: failed to delete secdesc. Error (%s)\n", tdb_errorstr(tdb_drivers)));
329 SAFE_FREE(dbuf.dptr);
335 /*******************************************************************
336 Fix an issue with security descriptors. Printer sec_desc must
337 use more than the generic bits that were previously used
338 in <= 3.0.14a. They must also have a owner and group SID assigned.
339 Otherwise, any printers than have been migrated to a Windows
340 host using printmig.exe will not be accessible.
341 *******************************************************************/
343 static int sec_desc_upg_fn( TDB_CONTEXT *the_tdb, TDB_DATA key,
344 TDB_DATA data, void *state )
347 SEC_DESC_BUF *sd_orig = NULL;
348 SEC_DESC_BUF *sd_new, *sd_store;
349 SEC_DESC *sec, *new_sec;
350 TALLOC_CTX *ctx = state;
355 if (!data.dptr || data.dsize == 0) {
359 if ( strncmp((const char *) key.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX) ) != 0 ) {
363 /* upgrade the security descriptor */
365 status = unmarshall_sec_desc_buf(ctx, data.dptr, data.dsize, &sd_orig);
366 if (!NT_STATUS_IS_OK(status)) {
367 /* delete bad entries */
368 DEBUG(0,("sec_desc_upg_fn: Failed to parse original sec_desc for %si. Deleting....\n",
369 (const char *)key.dptr ));
370 tdb_delete( tdb_printers, key );
379 /* is this even valid? */
385 /* update access masks */
387 for ( i=0; i<sec->dacl->num_aces; i++ ) {
388 switch ( sec->dacl->aces[i].access_mask ) {
389 case (GENERIC_READ_ACCESS | GENERIC_WRITE_ACCESS | GENERIC_EXECUTE_ACCESS):
390 sec->dacl->aces[i].access_mask = PRINTER_ACE_PRINT;
393 case GENERIC_ALL_ACCESS:
394 sec->dacl->aces[i].access_mask = PRINTER_ACE_FULL_CONTROL;
397 case READ_CONTROL_ACCESS:
398 sec->dacl->aces[i].access_mask = PRINTER_ACE_MANAGE_DOCUMENTS;
400 default: /* no change */
405 /* create a new SEC_DESC with the appropriate owner and group SIDs */
407 new_sec = make_sec_desc( ctx, SEC_DESC_REVISION, SEC_DESC_SELF_RELATIVE,
408 &global_sid_Builtin_Administrators,
409 &global_sid_Builtin_Administrators,
410 NULL, NULL, &size_new_sec );
414 sd_new = make_sec_desc_buf( ctx, size_new_sec, new_sec );
419 if ( !(sd_store = sec_desc_merge( ctx, sd_new, sd_orig )) ) {
420 DEBUG(0,("sec_desc_upg_fn: Failed to update sec_desc for %s\n", key.dptr ));
426 sd_size = ndr_size_security_descriptor(sd_store->sd, NULL, 0)
427 + sizeof(SEC_DESC_BUF);
429 status = marshall_sec_desc_buf(ctx, sd_store, &data.dptr, &data.dsize);
430 if (!NT_STATUS_IS_OK(status)) {
431 DEBUG(0,("sec_desc_upg_fn: Failed to parse new sec_desc for %s\n", key.dptr ));
435 result = tdb_store( tdb_printers, key, data, TDB_REPLACE );
437 /* 0 to continue and non-zero to stop traversal */
439 return (result == -1);
442 /*******************************************************************
443 *******************************************************************/
445 static bool upgrade_to_version_4(void)
450 DEBUG(0,("upgrade_to_version_4: upgrading printer security descriptors\n"));
452 if ( !(ctx = talloc_init( "upgrade_to_version_4" )) )
455 result = tdb_traverse( tdb_printers, sec_desc_upg_fn, ctx );
457 talloc_destroy( ctx );
459 return ( result != -1 );
462 /*******************************************************************
463 Fix an issue with security descriptors. Printer sec_desc must
464 use more than the generic bits that were previously used
465 in <= 3.0.14a. They must also have a owner and group SID assigned.
466 Otherwise, any printers than have been migrated to a Windows
467 host using printmig.exe will not be accessible.
468 *******************************************************************/
470 static int normalize_printers_fn( TDB_CONTEXT *the_tdb, TDB_DATA key,
471 TDB_DATA data, void *state )
473 TALLOC_CTX *ctx = talloc_tos();
476 if (!data.dptr || data.dsize == 0)
479 /* upgrade printer records and security descriptors */
481 if ( strncmp((const char *) key.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX) ) == 0 ) {
482 new_key = make_printer_tdbkey(ctx, (const char *)key.dptr+strlen(PRINTERS_PREFIX) );
484 else if ( strncmp((const char *) key.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX) ) == 0 ) {
485 new_key = make_printers_secdesc_tdbkey(ctx, (const char *)key.dptr+strlen(SECDESC_PREFIX) );
488 /* ignore this record */
492 /* delete the original record and store under the normalized key */
494 if ( tdb_delete( the_tdb, key ) != 0 ) {
495 DEBUG(0,("normalize_printers_fn: tdb_delete for [%s] failed!\n",
500 if ( tdb_store( the_tdb, new_key, data, TDB_REPLACE) != 0 ) {
501 DEBUG(0,("normalize_printers_fn: failed to store new record for [%s]!\n",
509 /*******************************************************************
510 *******************************************************************/
512 static bool upgrade_to_version_5(void)
517 DEBUG(0,("upgrade_to_version_5: normalizing printer keys\n"));
519 if ( !(ctx = talloc_init( "upgrade_to_version_5" )) )
522 result = tdb_traverse( tdb_printers, normalize_printers_fn, NULL );
524 talloc_destroy( ctx );
526 return ( result != -1 );
529 /****************************************************************************
530 Open the NT printing tdbs. Done once before fork().
531 ****************************************************************************/
533 bool nt_printing_init(struct messaging_context *msg_ctx)
535 const char *vstring = "INFO/version";
539 if ( tdb_drivers && tdb_printers && tdb_forms )
543 tdb_close(tdb_drivers);
544 tdb_drivers = tdb_open_log(state_path("ntdrivers.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
546 DEBUG(0,("nt_printing_init: Failed to open nt drivers database %s (%s)\n",
547 state_path("ntdrivers.tdb"), strerror(errno) ));
552 tdb_close(tdb_printers);
553 tdb_printers = tdb_open_log(state_path("ntprinters.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
555 DEBUG(0,("nt_printing_init: Failed to open nt printers database %s (%s)\n",
556 state_path("ntprinters.tdb"), strerror(errno) ));
561 tdb_close(tdb_forms);
562 tdb_forms = tdb_open_log(state_path("ntforms.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
564 DEBUG(0,("nt_printing_init: Failed to open nt forms database %s (%s)\n",
565 state_path("ntforms.tdb"), strerror(errno) ));
569 /* handle a Samba upgrade */
571 vers_id = tdb_fetch_int32(tdb_drivers, vstring);
573 DEBUG(10, ("Fresh database\n"));
574 tdb_store_int32( tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_5 );
575 vers_id = NTDRIVERS_DATABASE_VERSION_5;
578 if ( vers_id != NTDRIVERS_DATABASE_VERSION_5 ) {
580 if ((vers_id == NTDRIVERS_DATABASE_VERSION_1) || (IREV(vers_id) == NTDRIVERS_DATABASE_VERSION_1)) {
581 if (!upgrade_to_version_3())
583 tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_3);
584 vers_id = NTDRIVERS_DATABASE_VERSION_3;
587 if ((vers_id == NTDRIVERS_DATABASE_VERSION_2) || (IREV(vers_id) == NTDRIVERS_DATABASE_VERSION_2)) {
588 /* Written on a bigendian machine with old fetch_int code. Save as le. */
589 /* The only upgrade between V2 and V3 is to save the version in little-endian. */
590 tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_3);
591 vers_id = NTDRIVERS_DATABASE_VERSION_3;
594 if (vers_id == NTDRIVERS_DATABASE_VERSION_3 ) {
595 if ( !upgrade_to_version_4() )
597 tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_4);
598 vers_id = NTDRIVERS_DATABASE_VERSION_4;
601 if (vers_id == NTDRIVERS_DATABASE_VERSION_4 ) {
602 if ( !upgrade_to_version_5() )
604 tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_5);
605 vers_id = NTDRIVERS_DATABASE_VERSION_5;
609 if ( vers_id != NTDRIVERS_DATABASE_VERSION_5 ) {
610 DEBUG(0,("nt_printing_init: Unknown printer database version [%d]\n", vers_id));
615 update_c_setprinter(True);
618 * register callback to handle updating printers as new
619 * drivers are installed
622 messaging_register(msg_ctx, NULL, MSG_PRINTER_DRVUPGRADE,
623 do_drv_upgrade_printer);
626 * register callback to handle updating printer data
627 * when a driver is initialized
630 messaging_register(msg_ctx, NULL, MSG_PRINTERDATA_INIT_RESET,
631 reset_all_printerdata);
633 /* of course, none of the message callbacks matter if you don't
634 tell messages.c that you interested in receiving PRINT_GENERAL
635 msgs. This is done in claim_connection() */
638 if ( lp_security() == SEC_ADS ) {
639 win_rc = check_published_printers();
640 if (!W_ERROR_IS_OK(win_rc))
641 DEBUG(0, ("nt_printing_init: error checking published printers: %s\n", win_errstr(win_rc)));
647 /*******************************************************************
648 Function to allow filename parsing "the old way".
649 ********************************************************************/
651 static char *driver_unix_convert(connection_struct *conn,
652 const char *old_name,
653 SMB_STRUCT_STAT *pst)
655 TALLOC_CTX *ctx = talloc_tos();
656 char *name = talloc_strdup(ctx, old_name);
657 char *new_name = NULL;
663 name = unix_clean_name(ctx, name);
667 trim_string(name,"/","/");
668 unix_convert(ctx,conn, name, false, &new_name, NULL, pst);
672 /*******************************************************************
673 tdb traversal function for counting printers.
674 ********************************************************************/
676 static int traverse_counting_printers(TDB_CONTEXT *t, TDB_DATA key,
677 TDB_DATA data, void *context)
679 int *printer_count = (int*)context;
681 if (memcmp(PRINTERS_PREFIX, key.dptr, sizeof(PRINTERS_PREFIX)-1) == 0) {
683 DEBUG(10,("traverse_counting_printers: printer = [%s] printer_count = %d\n", key.dptr, *printer_count));
689 /*******************************************************************
690 Update the spooler global c_setprinter. This variable is initialized
691 when the parent smbd starts with the number of existing printers. It
692 is monotonically increased by the current number of printers *after*
693 each add or delete printer RPC. Only Microsoft knows why... JRR020119
694 ********************************************************************/
696 uint32 update_c_setprinter(bool initialize)
699 int32 printer_count = 0;
701 tdb_lock_bystring(tdb_printers, GLOBAL_C_SETPRINTER);
703 /* Traverse the tdb, counting the printers */
704 tdb_traverse(tdb_printers, traverse_counting_printers, (void *)&printer_count);
706 /* If initializing, set c_setprinter to current printers count
707 * otherwise, bump it by the current printer count
710 c_setprinter = tdb_fetch_int32(tdb_printers, GLOBAL_C_SETPRINTER) + printer_count;
712 c_setprinter = printer_count;
714 DEBUG(10,("update_c_setprinter: c_setprinter = %u\n", (unsigned int)c_setprinter));
715 tdb_store_int32(tdb_printers, GLOBAL_C_SETPRINTER, c_setprinter);
717 tdb_unlock_bystring(tdb_printers, GLOBAL_C_SETPRINTER);
719 return (uint32)c_setprinter;
722 /*******************************************************************
723 Get the spooler global c_setprinter, accounting for initialization.
724 ********************************************************************/
726 uint32 get_c_setprinter(void)
728 int32 c_setprinter = tdb_fetch_int32(tdb_printers, GLOBAL_C_SETPRINTER);
730 if (c_setprinter == (int32)-1)
731 c_setprinter = update_c_setprinter(True);
733 DEBUG(10,("get_c_setprinter: c_setprinter = %d\n", c_setprinter));
735 return (uint32)c_setprinter;
738 /****************************************************************************
739 Get builtin form struct list.
740 ****************************************************************************/
742 int get_builtin_ntforms(nt_forms_struct **list)
744 *list = (nt_forms_struct *)memdup(&default_forms[0], sizeof(default_forms));
748 return sizeof(default_forms) / sizeof(default_forms[0]);
751 /****************************************************************************
752 get a builtin form struct
753 ****************************************************************************/
755 bool get_a_builtin_ntform_by_string(const char *form_name, nt_forms_struct *form)
758 DEBUGADD(6,("Looking for builtin form %s \n", form_name));
759 count = sizeof(default_forms) / sizeof(default_forms[0]);
760 for (i=0;i<count;i++) {
761 if (strequal(form_name,default_forms[i].name)) {
762 DEBUGADD(6,("Found builtin form %s \n", form_name));
763 memcpy(form,&default_forms[i],sizeof(*form));
771 /****************************************************************************
772 get a form struct list.
773 ****************************************************************************/
775 int get_ntforms(nt_forms_struct **list)
777 TDB_DATA kbuf, newkey, dbuf;
778 nt_forms_struct form;
785 for (kbuf = tdb_firstkey(tdb_forms);
787 newkey = tdb_nextkey(tdb_forms, kbuf), free(kbuf.dptr), kbuf=newkey)
789 if (strncmp((const char *)kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) != 0)
792 dbuf = tdb_fetch(tdb_forms, kbuf);
796 fstrcpy(form.name, (const char *)kbuf.dptr+strlen(FORMS_PREFIX));
797 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "dddddddd",
798 &i, &form.flag, &form.width, &form.length, &form.left,
799 &form.top, &form.right, &form.bottom);
800 SAFE_FREE(dbuf.dptr);
801 if (ret != dbuf.dsize)
804 *list = SMB_REALLOC_ARRAY(*list, nt_forms_struct, n+1);
806 DEBUG(0,("get_ntforms: Realloc fail.\n"));
817 /****************************************************************************
818 write a form struct list
819 ****************************************************************************/
821 int write_ntforms(nt_forms_struct **list, int number)
823 TALLOC_CTX *ctx = talloc_tos();
830 for (i=0;i<number;i++) {
831 /* save index, so list is rebuilt in correct order */
832 len = tdb_pack(NULL, 0, "dddddddd",
833 i, (*list)[i].flag, (*list)[i].width, (*list)[i].length,
834 (*list)[i].left, (*list)[i].top, (*list)[i].right,
839 buf = TALLOC_ARRAY(ctx, char, len);
843 len = tdb_pack((uint8 *)buf, len, "dddddddd",
844 i, (*list)[i].flag, (*list)[i].width, (*list)[i].length,
845 (*list)[i].left, (*list)[i].top, (*list)[i].right,
847 key = talloc_asprintf(ctx, "%s%s", FORMS_PREFIX, (*list)[i].name);
852 dbuf.dptr = (uint8 *)buf;
853 if (tdb_store_bystring(tdb_forms, key, dbuf, TDB_REPLACE) != 0) {
865 /****************************************************************************
866 add a form struct at the end of the list
867 ****************************************************************************/
868 bool add_a_form(nt_forms_struct **list, struct spoolss_AddFormInfo1 *form, int *count)
874 * NT tries to add forms even when
875 * they are already in the base
876 * only update the values if already present
881 for (n=0; n<*count; n++) {
882 if ( strequal((*list)[n].name, form->form_name) ) {
889 if((*list=SMB_REALLOC_ARRAY(*list, nt_forms_struct, n+1)) == NULL) {
890 DEBUG(0,("add_a_form: failed to enlarge forms list!\n"));
893 fstrcpy((*list)[n].name, form->form_name);
897 (*list)[n].flag = form->flags;
898 (*list)[n].width = form->size.width;
899 (*list)[n].length = form->size.height;
900 (*list)[n].left = form->area.left;
901 (*list)[n].top = form->area.top;
902 (*list)[n].right = form->area.right;
903 (*list)[n].bottom = form->area.bottom;
905 DEBUG(6,("add_a_form: Successfully %s form [%s]\n",
906 update ? "updated" : "added", form->form_name));
911 /****************************************************************************
912 Delete a named form struct.
913 ****************************************************************************/
915 bool delete_a_form(nt_forms_struct **list, const char *del_name, int *count, WERROR *ret)
922 for (n=0; n<*count; n++) {
923 if (!strncmp((*list)[n].name, del_name, strlen(del_name))) {
924 DEBUG(103, ("delete_a_form, [%s] in list\n", del_name));
930 DEBUG(10,("delete_a_form, [%s] not found\n", del_name));
931 *ret = WERR_INVALID_PARAM;
935 if (asprintf(&key, "%s%s", FORMS_PREFIX, (*list)[n].name) < 0) {
939 if (tdb_delete_bystring(tdb_forms, key) != 0) {
948 /****************************************************************************
949 Update a form struct.
950 ****************************************************************************/
952 void update_a_form(nt_forms_struct **list, struct spoolss_AddFormInfo1 *form, int count)
956 DEBUG(106, ("[%s]\n", form->form_name));
957 for (n=0; n<count; n++) {
958 DEBUGADD(106, ("n [%d]:[%s]\n", n, (*list)[n].name));
959 if (!strncmp((*list)[n].name, form->form_name, strlen(form->form_name)))
963 if (n==count) return;
965 (*list)[n].flag = form->flags;
966 (*list)[n].width = form->size.width;
967 (*list)[n].length = form->size.height;
968 (*list)[n].left = form->area.left;
969 (*list)[n].top = form->area.top;
970 (*list)[n].right = form->area.right;
971 (*list)[n].bottom = form->area.bottom;
974 /****************************************************************************
975 Get the nt drivers list.
976 Traverse the database and look-up the matching names.
977 ****************************************************************************/
978 int get_ntdrivers(fstring **list, const char *architecture, uint32 version)
981 const char *short_archi;
983 TDB_DATA kbuf, newkey;
985 short_archi = get_short_archi(architecture);
990 if (asprintf(&key, "%s%s/%d/", DRIVERS_PREFIX,
991 short_archi, version) < 0) {
995 for (kbuf = tdb_firstkey(tdb_drivers);
997 newkey = tdb_nextkey(tdb_drivers, kbuf), free(kbuf.dptr), kbuf=newkey) {
999 if (strncmp((const char *)kbuf.dptr, key, strlen(key)) != 0)
1002 if((*list = SMB_REALLOC_ARRAY(*list, fstring, total+1)) == NULL) {
1003 DEBUG(0,("get_ntdrivers: failed to enlarge list!\n"));
1008 fstrcpy((*list)[total], (const char *)kbuf.dptr+strlen(key));
1016 /****************************************************************************
1017 Function to do the mapping between the long architecture name and
1019 ****************************************************************************/
1021 const char *get_short_archi(const char *long_archi)
1025 DEBUG(107,("Getting architecture dependant directory\n"));
1028 } while ( (archi_table[i].long_archi!=NULL ) &&
1029 StrCaseCmp(long_archi, archi_table[i].long_archi) );
1031 if (archi_table[i].long_archi==NULL) {
1032 DEBUGADD(10,("Unknown architecture [%s] !\n", long_archi));
1036 /* this might be client code - but shouldn't this be an fstrcpy etc? */
1038 DEBUGADD(108,("index: [%d]\n", i));
1039 DEBUGADD(108,("long architecture: [%s]\n", archi_table[i].long_archi));
1040 DEBUGADD(108,("short architecture: [%s]\n", archi_table[i].short_archi));
1042 return archi_table[i].short_archi;
1045 /****************************************************************************
1046 Version information in Microsoft files is held in a VS_VERSION_INFO structure.
1047 There are two case to be covered here: PE (Portable Executable) and NE (New
1048 Executable) files. Both files support the same INFO structure, but PE files
1049 store the signature in unicode, and NE files store it as !unicode.
1050 returns -1 on error, 1 on version info found, and 0 on no version info found.
1051 ****************************************************************************/
1053 static int get_file_version(files_struct *fsp, char *fname,uint32 *major, uint32 *minor)
1059 if ((buf=(char *)SMB_MALLOC(DOS_HEADER_SIZE)) == NULL) {
1060 DEBUG(0,("get_file_version: PE file [%s] DOS Header malloc failed bytes = %d\n",
1061 fname, DOS_HEADER_SIZE));
1065 if ((byte_count = vfs_read_data(fsp, buf, DOS_HEADER_SIZE)) < DOS_HEADER_SIZE) {
1066 DEBUG(3,("get_file_version: File [%s] DOS header too short, bytes read = %lu\n",
1067 fname, (unsigned long)byte_count));
1068 goto no_version_info;
1071 /* Is this really a DOS header? */
1072 if (SVAL(buf,DOS_HEADER_MAGIC_OFFSET) != DOS_HEADER_MAGIC) {
1073 DEBUG(6,("get_file_version: File [%s] bad DOS magic = 0x%x\n",
1074 fname, SVAL(buf,DOS_HEADER_MAGIC_OFFSET)));
1075 goto no_version_info;
1078 /* Skip OEM header (if any) and the DOS stub to start of Windows header */
1079 if (SMB_VFS_LSEEK(fsp, SVAL(buf,DOS_HEADER_LFANEW_OFFSET), SEEK_SET) == (SMB_OFF_T)-1) {
1080 DEBUG(3,("get_file_version: File [%s] too short, errno = %d\n",
1082 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
1083 goto no_version_info;
1086 /* Note: DOS_HEADER_SIZE and NE_HEADER_SIZE are incidentally same */
1087 if ((byte_count = vfs_read_data(fsp, buf, NE_HEADER_SIZE)) < NE_HEADER_SIZE) {
1088 DEBUG(3,("get_file_version: File [%s] Windows header too short, bytes read = %lu\n",
1089 fname, (unsigned long)byte_count));
1090 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
1091 goto no_version_info;
1094 /* The header may be a PE (Portable Executable) or an NE (New Executable) */
1095 if (IVAL(buf,PE_HEADER_SIGNATURE_OFFSET) == PE_HEADER_SIGNATURE) {
1096 unsigned int num_sections;
1097 unsigned int section_table_bytes;
1099 /* Just skip over optional header to get to section table */
1100 if (SMB_VFS_LSEEK(fsp,
1101 SVAL(buf,PE_HEADER_OPTIONAL_HEADER_SIZE)-(NE_HEADER_SIZE-PE_HEADER_SIZE),
1102 SEEK_CUR) == (SMB_OFF_T)-1) {
1103 DEBUG(3,("get_file_version: File [%s] Windows optional header too short, errno = %d\n",
1108 /* get the section table */
1109 num_sections = SVAL(buf,PE_HEADER_NUMBER_OF_SECTIONS);
1110 section_table_bytes = num_sections * PE_HEADER_SECT_HEADER_SIZE;
1111 if (section_table_bytes == 0)
1115 if ((buf=(char *)SMB_MALLOC(section_table_bytes)) == NULL) {
1116 DEBUG(0,("get_file_version: PE file [%s] section table malloc failed bytes = %d\n",
1117 fname, section_table_bytes));
1121 if ((byte_count = vfs_read_data(fsp, buf, section_table_bytes)) < section_table_bytes) {
1122 DEBUG(3,("get_file_version: PE file [%s] Section header too short, bytes read = %lu\n",
1123 fname, (unsigned long)byte_count));
1127 /* Iterate the section table looking for the resource section ".rsrc" */
1128 for (i = 0; i < num_sections; i++) {
1129 int sec_offset = i * PE_HEADER_SECT_HEADER_SIZE;
1131 if (strcmp(".rsrc", &buf[sec_offset+PE_HEADER_SECT_NAME_OFFSET]) == 0) {
1132 unsigned int section_pos = IVAL(buf,sec_offset+PE_HEADER_SECT_PTR_DATA_OFFSET);
1133 unsigned int section_bytes = IVAL(buf,sec_offset+PE_HEADER_SECT_SIZE_DATA_OFFSET);
1135 if (section_bytes == 0)
1139 if ((buf=(char *)SMB_MALLOC(section_bytes)) == NULL) {
1140 DEBUG(0,("get_file_version: PE file [%s] version malloc failed bytes = %d\n",
1141 fname, section_bytes));
1145 /* Seek to the start of the .rsrc section info */
1146 if (SMB_VFS_LSEEK(fsp, section_pos, SEEK_SET) == (SMB_OFF_T)-1) {
1147 DEBUG(3,("get_file_version: PE file [%s] too short for section info, errno = %d\n",
1152 if ((byte_count = vfs_read_data(fsp, buf, section_bytes)) < section_bytes) {
1153 DEBUG(3,("get_file_version: PE file [%s] .rsrc section too short, bytes read = %lu\n",
1154 fname, (unsigned long)byte_count));
1158 if (section_bytes < VS_VERSION_INFO_UNICODE_SIZE)
1161 for (i=0; i<section_bytes-VS_VERSION_INFO_UNICODE_SIZE; i++) {
1162 /* Scan for 1st 3 unicoded bytes followed by word aligned magic value */
1163 if (buf[i] == 'V' && buf[i+1] == '\0' && buf[i+2] == 'S') {
1164 /* Align to next long address */
1165 int pos = (i + sizeof(VS_SIGNATURE)*2 + 3) & 0xfffffffc;
1167 if (IVAL(buf,pos) == VS_MAGIC_VALUE) {
1168 *major = IVAL(buf,pos+VS_MAJOR_OFFSET);
1169 *minor = IVAL(buf,pos+VS_MINOR_OFFSET);
1171 DEBUG(6,("get_file_version: PE file [%s] Version = %08x:%08x (%d.%d.%d.%d)\n",
1172 fname, *major, *minor,
1173 (*major>>16)&0xffff, *major&0xffff,
1174 (*minor>>16)&0xffff, *minor&0xffff));
1183 /* Version info not found, fall back to origin date/time */
1184 DEBUG(10,("get_file_version: PE file [%s] has no version info\n", fname));
1188 } else if (SVAL(buf,NE_HEADER_SIGNATURE_OFFSET) == NE_HEADER_SIGNATURE) {
1189 if (CVAL(buf,NE_HEADER_TARGET_OS_OFFSET) != NE_HEADER_TARGOS_WIN ) {
1190 DEBUG(3,("get_file_version: NE file [%s] wrong target OS = 0x%x\n",
1191 fname, CVAL(buf,NE_HEADER_TARGET_OS_OFFSET)));
1192 /* At this point, we assume the file is in error. It still could be somthing
1193 * else besides a NE file, but it unlikely at this point. */
1197 /* Allocate a bit more space to speed up things */
1199 if ((buf=(char *)SMB_MALLOC(VS_NE_BUF_SIZE)) == NULL) {
1200 DEBUG(0,("get_file_version: NE file [%s] malloc failed bytes = %d\n",
1201 fname, PE_HEADER_SIZE));
1205 /* This is a HACK! I got tired of trying to sort through the messy
1206 * 'NE' file format. If anyone wants to clean this up please have at
1207 * it, but this works. 'NE' files will eventually fade away. JRR */
1208 while((byte_count = vfs_read_data(fsp, buf, VS_NE_BUF_SIZE)) > 0) {
1209 /* Cover case that should not occur in a well formed 'NE' .dll file */
1210 if (byte_count-VS_VERSION_INFO_SIZE <= 0) break;
1212 for(i=0; i<byte_count; i++) {
1213 /* Fast skip past data that can't possibly match */
1214 if (buf[i] != 'V') continue;
1216 /* Potential match data crosses buf boundry, move it to beginning
1217 * of buf, and fill the buf with as much as it will hold. */
1218 if (i>byte_count-VS_VERSION_INFO_SIZE) {
1221 memcpy(buf, &buf[i], byte_count-i);
1222 if ((bc = vfs_read_data(fsp, &buf[byte_count-i], VS_NE_BUF_SIZE-
1223 (byte_count-i))) < 0) {
1225 DEBUG(0,("get_file_version: NE file [%s] Read error, errno=%d\n",
1230 byte_count = bc + (byte_count - i);
1231 if (byte_count<VS_VERSION_INFO_SIZE) break;
1236 /* Check that the full signature string and the magic number that
1237 * follows exist (not a perfect solution, but the chances that this
1238 * occurs in code is, well, remote. Yes I know I'm comparing the 'V'
1239 * twice, as it is simpler to read the code. */
1240 if (strcmp(&buf[i], VS_SIGNATURE) == 0) {
1241 /* Compute skip alignment to next long address */
1242 int skip = -(SMB_VFS_LSEEK(fsp, 0, SEEK_CUR) - (byte_count - i) +
1243 sizeof(VS_SIGNATURE)) & 3;
1244 if (IVAL(buf,i+sizeof(VS_SIGNATURE)+skip) != 0xfeef04bd) continue;
1246 *major = IVAL(buf,i+sizeof(VS_SIGNATURE)+skip+VS_MAJOR_OFFSET);
1247 *minor = IVAL(buf,i+sizeof(VS_SIGNATURE)+skip+VS_MINOR_OFFSET);
1248 DEBUG(6,("get_file_version: NE file [%s] Version = %08x:%08x (%d.%d.%d.%d)\n",
1249 fname, *major, *minor,
1250 (*major>>16)&0xffff, *major&0xffff,
1251 (*minor>>16)&0xffff, *minor&0xffff));
1258 /* Version info not found, fall back to origin date/time */
1259 DEBUG(0,("get_file_version: NE file [%s] Version info not found\n", fname));
1264 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
1265 DEBUG(3,("get_file_version: File [%s] unknown file format, signature = 0x%x\n",
1266 fname, IVAL(buf,PE_HEADER_SIGNATURE_OFFSET)));
1277 /****************************************************************************
1278 Drivers for Microsoft systems contain multiple files. Often, multiple drivers
1279 share one or more files. During the MS installation process files are checked
1280 to insure that only a newer version of a shared file is installed over an
1281 older version. There are several possibilities for this comparison. If there
1282 is no previous version, the new one is newer (obviously). If either file is
1283 missing the version info structure, compare the creation date (on Unix use
1284 the modification date). Otherwise chose the numerically larger version number.
1285 ****************************************************************************/
1287 static int file_version_is_newer(connection_struct *conn, fstring new_file, fstring old_file)
1289 bool use_version = true;
1290 char *filepath = NULL;
1294 time_t new_create_time;
1298 time_t old_create_time;
1300 files_struct *fsp = NULL;
1302 SMB_STRUCT_STAT stat_buf;
1306 SET_STAT_INVALID(st);
1307 SET_STAT_INVALID(stat_buf);
1308 new_create_time = (time_t)0;
1309 old_create_time = (time_t)0;
1311 /* Get file version info (if available) for previous file (if it exists) */
1312 filepath = driver_unix_convert(conn,old_file,&stat_buf);
1317 status = SMB_VFS_CREATE_FILE(
1320 0, /* root_dir_fid */
1321 filepath, /* fname */
1322 0, /* create_file_flags */
1323 FILE_GENERIC_READ, /* access_mask */
1324 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
1325 FILE_OPEN, /* create_disposition*/
1326 0, /* create_options */
1327 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
1328 INTERNAL_OPEN_ONLY, /* oplock_request */
1329 0, /* allocation_size */
1334 &stat_buf); /* psbuf */
1336 if (!NT_STATUS_IS_OK(status)) {
1337 /* Old file not found, so by definition new file is in fact newer */
1338 DEBUG(10,("file_version_is_newer: Can't open old file [%s], errno = %d\n",
1343 int ret = get_file_version(fsp, old_file, &old_major, &old_minor);
1349 DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
1351 use_version = false;
1352 if (SMB_VFS_FSTAT(fsp, &st) == -1) {
1355 old_create_time = st.st_mtime;
1356 DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n",
1357 (long)old_create_time));
1360 close_file(NULL, fsp, NORMAL_CLOSE);
1363 /* Get file version info (if available) for new file */
1364 filepath = driver_unix_convert(conn,new_file,&stat_buf);
1369 status = SMB_VFS_CREATE_FILE(
1372 0, /* root_dir_fid */
1373 filepath, /* fname */
1374 0, /* create_file_flags */
1375 FILE_GENERIC_READ, /* access_mask */
1376 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
1377 FILE_OPEN, /* create_disposition*/
1378 0, /* create_options */
1379 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
1380 INTERNAL_OPEN_ONLY, /* oplock_request */
1381 0, /* allocation_size */
1386 &stat_buf); /* psbuf */
1388 if (!NT_STATUS_IS_OK(status)) {
1389 /* New file not found, this shouldn't occur if the caller did its job */
1390 DEBUG(3,("file_version_is_newer: Can't open new file [%s], errno = %d\n",
1395 int ret = get_file_version(fsp, new_file, &new_major, &new_minor);
1401 DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
1403 use_version = false;
1404 if (SMB_VFS_FSTAT(fsp, &st) == -1) {
1407 new_create_time = st.st_mtime;
1408 DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n",
1409 (long)new_create_time));
1412 close_file(NULL, fsp, NORMAL_CLOSE);
1415 if (use_version && (new_major != old_major || new_minor != old_minor)) {
1416 /* Compare versions and choose the larger version number */
1417 if (new_major > old_major ||
1418 (new_major == old_major && new_minor > old_minor)) {
1420 DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file, new_file));
1424 DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file));
1429 /* Compare modification time/dates and choose the newest time/date */
1430 if (new_create_time > old_create_time) {
1431 DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file, new_file));
1435 DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file));
1442 close_file(NULL, fsp, NORMAL_CLOSE);
1446 /****************************************************************************
1447 Determine the correct cVersion associated with an architecture and driver
1448 ****************************************************************************/
1449 static uint32 get_correct_cversion(struct pipes_struct *p,
1450 const char *architecture,
1451 fstring driverpath_in,
1456 char *driverpath = NULL;
1457 files_struct *fsp = NULL;
1459 connection_struct *conn = NULL;
1462 fstring printdollar;
1463 int printdollar_snum;
1465 SET_STAT_INVALID(st);
1467 *perr = WERR_INVALID_PARAM;
1469 /* If architecture is Windows 95/98/ME, the version is always 0. */
1470 if (strcmp(architecture, SPL_ARCH_WIN40) == 0) {
1471 DEBUG(10,("get_correct_cversion: Driver is Win9x, cversion = 0\n"));
1476 /* If architecture is Windows x64, the version is always 3. */
1477 if (strcmp(architecture, SPL_ARCH_X64) == 0) {
1478 DEBUG(10,("get_correct_cversion: Driver is x64, cversion = 3\n"));
1483 fstrcpy(printdollar, "print$");
1485 printdollar_snum = find_service(printdollar);
1486 if (printdollar_snum == -1) {
1487 *perr = WERR_NO_SUCH_SHARE;
1491 nt_status = create_conn_struct(talloc_tos(), &conn, printdollar_snum,
1492 lp_pathname(printdollar_snum),
1493 p->server_info, &oldcwd);
1494 if (!NT_STATUS_IS_OK(nt_status)) {
1495 DEBUG(0,("get_correct_cversion: create_conn_struct "
1496 "returned %s\n", nt_errstr(nt_status)));
1497 *perr = ntstatus_to_werror(nt_status);
1501 /* Open the driver file (Portable Executable format) and determine the
1502 * deriver the cversion. */
1503 driverpath = talloc_asprintf(talloc_tos(),
1512 driverpath = driver_unix_convert(conn,driverpath,&st);
1518 if (!vfs_file_exist(conn, driverpath, &st)) {
1519 *perr = WERR_BADFILE;
1523 status = SMB_VFS_CREATE_FILE(
1526 0, /* root_dir_fid */
1527 driverpath, /* fname */
1528 0, /* create_file_flags */
1529 FILE_GENERIC_READ, /* access_mask */
1530 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
1531 FILE_OPEN, /* create_disposition*/
1532 0, /* create_options */
1533 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
1534 INTERNAL_OPEN_ONLY, /* oplock_request */
1535 0, /* allocation_size */
1542 if (!NT_STATUS_IS_OK(status)) {
1543 DEBUG(3,("get_correct_cversion: Can't open file [%s], errno = %d\n",
1544 driverpath, errno));
1545 *perr = WERR_ACCESS_DENIED;
1550 int ret = get_file_version(fsp, driverpath, &major, &minor);
1551 if (ret == -1) goto error_exit;
1554 DEBUG(6,("get_correct_cversion: Version info not found [%s]\n", driverpath));
1559 * This is a Microsoft'ism. See references in MSDN to VER_FILEVERSION
1560 * for more details. Version in this case is not just the version of the
1561 * file, but the version in the sense of kernal mode (2) vs. user mode
1562 * (3) drivers. Other bits of the version fields are the version info.
1565 cversion = major & 0x0000ffff;
1567 case 2: /* WinNT drivers */
1568 case 3: /* Win2K drivers */
1572 DEBUG(6,("get_correct_cversion: cversion invalid [%s] cversion = %d\n",
1573 driverpath, cversion));
1577 DEBUG(10,("get_correct_cversion: Version info found [%s] major = 0x%x minor = 0x%x\n",
1578 driverpath, major, minor));
1581 DEBUG(10,("get_correct_cversion: Driver file [%s] cversion = %d\n",
1582 driverpath, cversion));
1590 close_file(NULL, fsp, NORMAL_CLOSE);
1593 vfs_ChDir(conn, oldcwd);
1594 conn_free_internal(conn);
1596 if (cversion != -1) {
1602 /****************************************************************************
1603 ****************************************************************************/
1604 static WERROR clean_up_driver_struct_level_3(struct pipes_struct *rpc_pipe,
1605 NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver)
1607 const char *architecture;
1613 /* clean up the driver name.
1614 * we can get .\driver.dll
1615 * or worse c:\windows\system\driver.dll !
1617 /* using an intermediate string to not have overlaping memcpy()'s */
1618 if ((p = strrchr(driver->driverpath,'\\')) != NULL) {
1619 fstrcpy(new_name, p+1);
1620 fstrcpy(driver->driverpath, new_name);
1623 if ((p = strrchr(driver->datafile,'\\')) != NULL) {
1624 fstrcpy(new_name, p+1);
1625 fstrcpy(driver->datafile, new_name);
1628 if ((p = strrchr(driver->configfile,'\\')) != NULL) {
1629 fstrcpy(new_name, p+1);
1630 fstrcpy(driver->configfile, new_name);
1633 if ((p = strrchr(driver->helpfile,'\\')) != NULL) {
1634 fstrcpy(new_name, p+1);
1635 fstrcpy(driver->helpfile, new_name);
1638 if (driver->dependentfiles) {
1639 for (i=0; *driver->dependentfiles[i]; i++) {
1640 if ((p = strrchr(driver->dependentfiles[i],'\\')) != NULL) {
1641 fstrcpy(new_name, p+1);
1642 fstrcpy(driver->dependentfiles[i], new_name);
1647 architecture = get_short_archi(driver->environment);
1648 if (!architecture) {
1649 return WERR_UNKNOWN_PRINTER_DRIVER;
1652 /* jfm:7/16/2000 the client always sends the cversion=0.
1653 * The server should check which version the driver is by reading
1654 * the PE header of driver->driverpath.
1656 * For Windows 95/98 the version is 0 (so the value sent is correct)
1657 * For Windows NT (the architecture doesn't matter)
1658 * NT 3.1: cversion=0
1659 * NT 3.5/3.51: cversion=1
1663 if ((driver->cversion = get_correct_cversion(rpc_pipe, architecture,
1671 /****************************************************************************
1672 ****************************************************************************/
1673 static WERROR clean_up_driver_struct_level_6(struct pipes_struct *rpc_pipe,
1674 NT_PRINTER_DRIVER_INFO_LEVEL_6 *driver)
1676 const char *architecture;
1682 /* clean up the driver name.
1683 * we can get .\driver.dll
1684 * or worse c:\windows\system\driver.dll !
1686 /* using an intermediate string to not have overlaping memcpy()'s */
1687 if ((p = strrchr(driver->driverpath,'\\')) != NULL) {
1688 fstrcpy(new_name, p+1);
1689 fstrcpy(driver->driverpath, new_name);
1692 if ((p = strrchr(driver->datafile,'\\')) != NULL) {
1693 fstrcpy(new_name, p+1);
1694 fstrcpy(driver->datafile, new_name);
1697 if ((p = strrchr(driver->configfile,'\\')) != NULL) {
1698 fstrcpy(new_name, p+1);
1699 fstrcpy(driver->configfile, new_name);
1702 if ((p = strrchr(driver->helpfile,'\\')) != NULL) {
1703 fstrcpy(new_name, p+1);
1704 fstrcpy(driver->helpfile, new_name);
1707 if (driver->dependentfiles) {
1708 for (i=0; *driver->dependentfiles[i]; i++) {
1709 if ((p = strrchr(driver->dependentfiles[i],'\\')) != NULL) {
1710 fstrcpy(new_name, p+1);
1711 fstrcpy(driver->dependentfiles[i], new_name);
1716 architecture = get_short_archi(driver->environment);
1717 if (!architecture) {
1718 return WERR_UNKNOWN_PRINTER_DRIVER;
1721 /* jfm:7/16/2000 the client always sends the cversion=0.
1722 * The server should check which version the driver is by reading
1723 * the PE header of driver->driverpath.
1725 * For Windows 95/98 the version is 0 (so the value sent is correct)
1726 * For Windows NT (the architecture doesn't matter)
1727 * NT 3.1: cversion=0
1728 * NT 3.5/3.51: cversion=1
1733 if ((driver->version = get_correct_cversion(rpc_pipe, architecture,
1741 /****************************************************************************
1742 ****************************************************************************/
1743 WERROR clean_up_driver_struct(struct pipes_struct *rpc_pipe,
1744 NT_PRINTER_DRIVER_INFO_LEVEL driver_abstract,
1750 NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver;
1751 driver=driver_abstract.info_3;
1752 return clean_up_driver_struct_level_3(rpc_pipe,
1757 NT_PRINTER_DRIVER_INFO_LEVEL_6 *driver;
1758 driver=driver_abstract.info_6;
1759 return clean_up_driver_struct_level_6(rpc_pipe,
1763 return WERR_INVALID_PARAM;
1767 /****************************************************************************
1768 This function sucks and should be replaced. JRA.
1769 ****************************************************************************/
1771 static void convert_level_6_to_level3(NT_PRINTER_DRIVER_INFO_LEVEL_3 *dst, NT_PRINTER_DRIVER_INFO_LEVEL_6 *src)
1773 dst->cversion = src->version;
1775 fstrcpy( dst->name, src->name);
1776 fstrcpy( dst->environment, src->environment);
1777 fstrcpy( dst->driverpath, src->driverpath);
1778 fstrcpy( dst->datafile, src->datafile);
1779 fstrcpy( dst->configfile, src->configfile);
1780 fstrcpy( dst->helpfile, src->helpfile);
1781 fstrcpy( dst->monitorname, src->monitorname);
1782 fstrcpy( dst->defaultdatatype, src->defaultdatatype);
1783 dst->dependentfiles = src->dependentfiles;
1786 #if 0 /* Debugging function */
1788 static char* ffmt(unsigned char *c){
1790 static char ffmt_str[17];
1792 for (i=0; i<16; i++) {
1793 if ((c[i] < ' ') || (c[i] > '~'))
1804 /****************************************************************************
1805 ****************************************************************************/
1806 WERROR move_driver_to_download_area(struct pipes_struct *p,
1807 NT_PRINTER_DRIVER_INFO_LEVEL driver_abstract,
1808 uint32 level, WERROR *perr)
1810 NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver;
1811 NT_PRINTER_DRIVER_INFO_LEVEL_3 converted_driver;
1812 const char *architecture;
1813 char *new_dir = NULL;
1814 char *old_name = NULL;
1815 char *new_name = NULL;
1816 connection_struct *conn = NULL;
1820 TALLOC_CTX *ctx = talloc_tos();
1823 fstring printdollar;
1824 int printdollar_snum;
1829 driver=driver_abstract.info_3;
1830 else if (level==6) {
1831 convert_level_6_to_level3(&converted_driver, driver_abstract.info_6);
1832 driver = &converted_driver;
1834 DEBUG(0,("move_driver_to_download_area: Unknown info level (%u)\n", (unsigned int)level ));
1835 return WERR_UNKNOWN_LEVEL;
1838 architecture = get_short_archi(driver->environment);
1839 if (!architecture) {
1840 return WERR_UNKNOWN_PRINTER_DRIVER;
1843 fstrcpy(printdollar, "print$");
1845 printdollar_snum = find_service(printdollar);
1846 if (printdollar_snum == -1) {
1847 *perr = WERR_NO_SUCH_SHARE;
1848 return WERR_NO_SUCH_SHARE;
1851 nt_status = create_conn_struct(talloc_tos(), &conn, printdollar_snum,
1852 lp_pathname(printdollar_snum),
1853 p->server_info, &oldcwd);
1854 if (!NT_STATUS_IS_OK(nt_status)) {
1855 DEBUG(0,("move_driver_to_download_area: create_conn_struct "
1856 "returned %s\n", nt_errstr(nt_status)));
1857 *perr = ntstatus_to_werror(nt_status);
1861 DEBUG(5,("Creating first directory\n"));
1862 new_dir = talloc_asprintf(ctx,
1870 new_dir = driver_unix_convert(conn,new_dir,&st);
1876 create_directory(conn, NULL, new_dir);
1878 /* For each driver file, archi\filexxx.yyy, if there is a duplicate file
1879 * listed for this driver which has already been moved, skip it (note:
1880 * drivers may list the same file name several times. Then check if the
1881 * file already exists in archi\cversion\, if so, check that the version
1882 * info (or time stamps if version info is unavailable) is newer (or the
1883 * date is later). If it is, move it to archi\cversion\filexxx.yyy.
1884 * Otherwise, delete the file.
1886 * If a file is not moved to archi\cversion\ because of an error, all the
1887 * rest of the 'unmoved' driver files are removed from archi\. If one or
1888 * more of the driver's files was already moved to archi\cversion\, it
1889 * potentially leaves the driver in a partially updated state. Version
1890 * trauma will most likely occur if an client attempts to use any printer
1891 * bound to the driver. Perhaps a rewrite to make sure the moves can be
1892 * done is appropriate... later JRR
1895 DEBUG(5,("Moving files now !\n"));
1897 if (driver->driverpath && strlen(driver->driverpath)) {
1898 new_name = talloc_asprintf(ctx,
1901 driver->driverpath);
1906 old_name = talloc_asprintf(ctx,
1909 driver->driverpath);
1915 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1916 new_name = driver_unix_convert(conn,new_name,&st);
1921 if ( !NT_STATUS_IS_OK(copy_file(ctx,conn, new_name, old_name, OPENX_FILE_EXISTS_TRUNCATE|
1922 OPENX_FILE_CREATE_IF_NOT_EXIST, 0, False))) {
1923 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1924 new_name, old_name));
1925 *perr = WERR_ACCESS_DENIED;
1931 if (driver->datafile && strlen(driver->datafile)) {
1932 if (!strequal(driver->datafile, driver->driverpath)) {
1933 new_name = talloc_asprintf(ctx,
1941 old_name = talloc_asprintf(ctx,
1949 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1950 new_name = driver_unix_convert(conn,new_name,&st);
1955 if ( !NT_STATUS_IS_OK(copy_file(ctx,conn, new_name, old_name, OPENX_FILE_EXISTS_TRUNCATE|
1956 OPENX_FILE_CREATE_IF_NOT_EXIST, 0, False))) {
1957 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1958 new_name, old_name));
1959 *perr = WERR_ACCESS_DENIED;
1966 if (driver->configfile && strlen(driver->configfile)) {
1967 if (!strequal(driver->configfile, driver->driverpath) &&
1968 !strequal(driver->configfile, driver->datafile)) {
1969 new_name = talloc_asprintf(ctx,
1972 driver->configfile);
1977 old_name = talloc_asprintf(ctx,
1980 driver->configfile);
1985 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1986 new_name = driver_unix_convert(conn,new_name,&st);
1991 if ( !NT_STATUS_IS_OK(copy_file(ctx,conn, new_name, old_name, OPENX_FILE_EXISTS_TRUNCATE|
1992 OPENX_FILE_CREATE_IF_NOT_EXIST, 0, False))) {
1993 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1994 new_name, old_name));
1995 *perr = WERR_ACCESS_DENIED;
2002 if (driver->helpfile && strlen(driver->helpfile)) {
2003 if (!strequal(driver->helpfile, driver->driverpath) &&
2004 !strequal(driver->helpfile, driver->datafile) &&
2005 !strequal(driver->helpfile, driver->configfile)) {
2006 new_name = talloc_asprintf(ctx,
2014 old_name = talloc_asprintf(ctx,
2022 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
2023 new_name = driver_unix_convert(conn,new_name,&st);
2028 if ( !NT_STATUS_IS_OK(copy_file(ctx,conn, new_name, old_name, OPENX_FILE_EXISTS_TRUNCATE|
2029 OPENX_FILE_CREATE_IF_NOT_EXIST, 0, False))) {
2030 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
2031 new_name, old_name));
2032 *perr = WERR_ACCESS_DENIED;
2039 if (driver->dependentfiles) {
2040 for (i=0; *driver->dependentfiles[i]; i++) {
2041 if (!strequal(driver->dependentfiles[i], driver->driverpath) &&
2042 !strequal(driver->dependentfiles[i], driver->datafile) &&
2043 !strequal(driver->dependentfiles[i], driver->configfile) &&
2044 !strequal(driver->dependentfiles[i], driver->helpfile)) {
2046 for (j=0; j < i; j++) {
2047 if (strequal(driver->dependentfiles[i], driver->dependentfiles[j])) {
2052 new_name = talloc_asprintf(ctx,
2055 driver->dependentfiles[i]);
2060 old_name = talloc_asprintf(ctx,
2063 driver->dependentfiles[i]);
2068 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
2069 new_name = driver_unix_convert(conn,new_name,&st);
2074 if ( !NT_STATUS_IS_OK(copy_file(ctx,conn, new_name, old_name,
2075 OPENX_FILE_EXISTS_TRUNCATE|
2076 OPENX_FILE_CREATE_IF_NOT_EXIST, 0, False))) {
2077 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
2078 new_name, old_name));
2079 *perr = WERR_ACCESS_DENIED;
2091 vfs_ChDir(conn, oldcwd);
2092 conn_free_internal(conn);
2095 if (W_ERROR_EQUAL(*perr, WERR_OK)) {
2099 return WERR_UNKNOWN_PRINTER_DRIVER;
2104 /****************************************************************************
2105 ****************************************************************************/
2107 static uint32 add_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver)
2109 TALLOC_CTX *ctx = talloc_tos();
2111 const char *architecture;
2112 char *directory = NULL;
2119 architecture = get_short_archi(driver->environment);
2120 if (!architecture) {
2124 /* The names are relative. We store them in the form: \print$\arch\version\driver.xxx
2125 * \\server is added in the rpc server layer.
2126 * It does make sense to NOT store the server's name in the printer TDB.
2129 directory = talloc_asprintf(ctx, "\\print$\\%s\\%d\\",
2130 architecture, driver->cversion);
2135 /* .inf files do not always list a file for each of the four standard files.
2136 * Don't prepend a path to a null filename, or client claims:
2137 * "The server on which the printer resides does not have a suitable
2138 * <printer driver name> printer driver installed. Click OK if you
2139 * wish to install the driver on your local machine."
2141 if (strlen(driver->driverpath)) {
2142 fstrcpy(temp_name, driver->driverpath);
2143 slprintf(driver->driverpath, sizeof(driver->driverpath)-1, "%s%s", directory, temp_name);
2146 if (strlen(driver->datafile)) {
2147 fstrcpy(temp_name, driver->datafile);
2148 slprintf(driver->datafile, sizeof(driver->datafile)-1, "%s%s", directory, temp_name);
2151 if (strlen(driver->configfile)) {
2152 fstrcpy(temp_name, driver->configfile);
2153 slprintf(driver->configfile, sizeof(driver->configfile)-1, "%s%s", directory, temp_name);
2156 if (strlen(driver->helpfile)) {
2157 fstrcpy(temp_name, driver->helpfile);
2158 slprintf(driver->helpfile, sizeof(driver->helpfile)-1, "%s%s", directory, temp_name);
2161 if (driver->dependentfiles) {
2162 for (i=0; *driver->dependentfiles[i]; i++) {
2163 fstrcpy(temp_name, driver->dependentfiles[i]);
2164 slprintf(driver->dependentfiles[i], sizeof(driver->dependentfiles[i])-1, "%s%s", directory, temp_name);
2168 key = talloc_asprintf(ctx, "%s%s/%d/%s", DRIVERS_PREFIX,
2169 architecture, driver->cversion, driver->name);
2174 DEBUG(5,("add_a_printer_driver_3: Adding driver with key %s\n", key ));
2181 len += tdb_pack(buf+len, buflen-len, "dffffffff",
2184 driver->environment,
2189 driver->monitorname,
2190 driver->defaultdatatype);
2192 if (driver->dependentfiles) {
2193 for (i=0; *driver->dependentfiles[i]; i++) {
2194 len += tdb_pack(buf+len, buflen-len, "f",
2195 driver->dependentfiles[i]);
2199 if (len != buflen) {
2200 buf = (uint8 *)SMB_REALLOC(buf, len);
2202 DEBUG(0,("add_a_printer_driver_3: failed to enlarge buffer\n!"));
2213 ret = tdb_store_bystring(tdb_drivers, key, dbuf, TDB_REPLACE);
2217 DEBUG(0,("add_a_printer_driver_3: Adding driver with key %s failed.\n", key ));
2223 /****************************************************************************
2224 ****************************************************************************/
2225 static uint32 add_a_printer_driver_6(NT_PRINTER_DRIVER_INFO_LEVEL_6 *driver)
2227 NT_PRINTER_DRIVER_INFO_LEVEL_3 info3;
2230 info3.cversion = driver->version;
2231 fstrcpy(info3.name,driver->name);
2232 fstrcpy(info3.environment,driver->environment);
2233 fstrcpy(info3.driverpath,driver->driverpath);
2234 fstrcpy(info3.datafile,driver->datafile);
2235 fstrcpy(info3.configfile,driver->configfile);
2236 fstrcpy(info3.helpfile,driver->helpfile);
2237 fstrcpy(info3.monitorname,driver->monitorname);
2238 fstrcpy(info3.defaultdatatype,driver->defaultdatatype);
2239 info3.dependentfiles = driver->dependentfiles;
2241 return add_a_printer_driver_3(&info3);
2245 /****************************************************************************
2246 ****************************************************************************/
2247 static WERROR get_a_printer_driver_3_default(NT_PRINTER_DRIVER_INFO_LEVEL_3 **info_ptr, const char *driver, const char *arch)
2249 NT_PRINTER_DRIVER_INFO_LEVEL_3 info;
2253 fstrcpy(info.name, driver);
2254 fstrcpy(info.defaultdatatype, "RAW");
2256 fstrcpy(info.driverpath, "");
2257 fstrcpy(info.datafile, "");
2258 fstrcpy(info.configfile, "");
2259 fstrcpy(info.helpfile, "");
2261 if ((info.dependentfiles= SMB_MALLOC_ARRAY(fstring, 2)) == NULL)
2264 memset(info.dependentfiles, '\0', 2*sizeof(fstring));
2265 fstrcpy(info.dependentfiles[0], "");
2267 *info_ptr = (NT_PRINTER_DRIVER_INFO_LEVEL_3 *)memdup(&info, sizeof(info));
2269 SAFE_FREE(info.dependentfiles);
2276 /****************************************************************************
2277 ****************************************************************************/
2278 static WERROR get_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 **info_ptr,
2279 const char *drivername, const char *arch,
2282 NT_PRINTER_DRIVER_INFO_LEVEL_3 driver;
2284 const char *architecture;
2289 ZERO_STRUCT(driver);
2291 architecture = get_short_archi(arch);
2292 if ( !architecture ) {
2293 return WERR_UNKNOWN_PRINTER_DRIVER;
2296 /* Windows 4.0 (i.e. win9x) should always use a version of 0 */
2298 if ( strcmp( architecture, SPL_ARCH_WIN40 ) == 0 )
2301 DEBUG(8,("get_a_printer_driver_3: [%s%s/%d/%s]\n", DRIVERS_PREFIX, architecture, version, drivername));
2303 if (asprintf(&key, "%s%s/%d/%s", DRIVERS_PREFIX,
2304 architecture, version, drivername) < 0) {
2308 dbuf = tdb_fetch_bystring(tdb_drivers, key);
2311 return WERR_UNKNOWN_PRINTER_DRIVER;
2314 len += tdb_unpack(dbuf.dptr, dbuf.dsize, "dffffffff",
2323 driver.defaultdatatype);
2326 while (len < dbuf.dsize) {
2327 driver.dependentfiles = SMB_REALLOC_ARRAY(driver.dependentfiles, fstring, i+2);
2328 if ( !driver.dependentfiles ) {
2329 DEBUG(0,("get_a_printer_driver_3: failed to enlarge buffer!\n"));
2333 len += tdb_unpack(dbuf.dptr+len, dbuf.dsize-len, "f",
2334 &driver.dependentfiles[i]);
2338 if ( driver.dependentfiles )
2339 fstrcpy( driver.dependentfiles[i], "" );
2341 SAFE_FREE(dbuf.dptr);
2344 if (len != dbuf.dsize) {
2345 SAFE_FREE(driver.dependentfiles);
2347 return get_a_printer_driver_3_default(info_ptr, drivername, arch);
2350 *info_ptr = (NT_PRINTER_DRIVER_INFO_LEVEL_3 *)memdup(&driver, sizeof(driver));
2352 SAFE_FREE(driver.dependentfiles);
2359 /****************************************************************************
2360 Debugging function, dump at level 6 the struct in the logs.
2361 ****************************************************************************/
2363 static uint32 dump_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
2366 NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3;
2369 DEBUG(20,("Dumping printer driver at level [%d]\n", level));
2375 if (driver.info_3 == NULL)
2378 info3=driver.info_3;
2380 DEBUGADD(20,("version:[%d]\n", info3->cversion));
2381 DEBUGADD(20,("name:[%s]\n", info3->name));
2382 DEBUGADD(20,("environment:[%s]\n", info3->environment));
2383 DEBUGADD(20,("driverpath:[%s]\n", info3->driverpath));
2384 DEBUGADD(20,("datafile:[%s]\n", info3->datafile));
2385 DEBUGADD(20,("configfile:[%s]\n", info3->configfile));
2386 DEBUGADD(20,("helpfile:[%s]\n", info3->helpfile));
2387 DEBUGADD(20,("monitorname:[%s]\n", info3->monitorname));
2388 DEBUGADD(20,("defaultdatatype:[%s]\n", info3->defaultdatatype));
2390 for (i=0; info3->dependentfiles &&
2391 *info3->dependentfiles[i]; i++) {
2392 DEBUGADD(20,("dependentfile:[%s]\n",
2393 info3->dependentfiles[i]));
2400 DEBUGADD(20,("dump_a_printer_driver: Level %u not implemented\n", (unsigned int)level));
2408 /****************************************************************************
2409 ****************************************************************************/
2410 int pack_devicemode(NT_DEVICEMODE *nt_devmode, uint8 *buf, int buflen)
2414 len += tdb_pack(buf+len, buflen-len, "p", nt_devmode);
2419 len += tdb_pack(buf+len, buflen-len, "ffwwwwwwwwwwwwwwwwwwddddddddddddddp",
2420 nt_devmode->devicename,
2421 nt_devmode->formname,
2423 nt_devmode->specversion,
2424 nt_devmode->driverversion,
2426 nt_devmode->driverextra,
2427 nt_devmode->orientation,
2428 nt_devmode->papersize,
2429 nt_devmode->paperlength,
2430 nt_devmode->paperwidth,
2433 nt_devmode->defaultsource,
2434 nt_devmode->printquality,
2437 nt_devmode->yresolution,
2438 nt_devmode->ttoption,
2439 nt_devmode->collate,
2440 nt_devmode->logpixels,
2443 nt_devmode->bitsperpel,
2444 nt_devmode->pelswidth,
2445 nt_devmode->pelsheight,
2446 nt_devmode->displayflags,
2447 nt_devmode->displayfrequency,
2448 nt_devmode->icmmethod,
2449 nt_devmode->icmintent,
2450 nt_devmode->mediatype,
2451 nt_devmode->dithertype,
2452 nt_devmode->reserved1,
2453 nt_devmode->reserved2,
2454 nt_devmode->panningwidth,
2455 nt_devmode->panningheight,
2456 nt_devmode->nt_dev_private);
2458 if (nt_devmode->nt_dev_private) {
2459 len += tdb_pack(buf+len, buflen-len, "B",
2460 nt_devmode->driverextra,
2461 nt_devmode->nt_dev_private);
2464 DEBUG(8,("Packed devicemode [%s]\n", nt_devmode->formname));
2469 /****************************************************************************
2470 Pack all values in all printer keys
2471 ***************************************************************************/
2473 static int pack_values(NT_PRINTER_DATA *data, uint8 *buf, int buflen)
2477 REGISTRY_VALUE *val;
2478 REGVAL_CTR *val_ctr;
2485 /* loop over all keys */
2487 for ( i=0; i<data->num_keys; i++ ) {
2488 val_ctr = data->keys[i].values;
2489 num_values = regval_ctr_numvals( val_ctr );
2491 /* pack the keyname followed by a empty value */
2493 len += tdb_pack(buf+len, buflen-len, "pPdB",
2494 &data->keys[i].name,
2500 /* now loop over all values */
2502 for ( j=0; j<num_values; j++ ) {
2503 /* pathname should be stored as <key>\<value> */
2505 val = regval_ctr_specific_value( val_ctr, j );
2506 if (asprintf(&path, "%s\\%s",
2508 regval_name(val)) < 0) {
2512 len += tdb_pack(buf+len, buflen-len, "pPdB",
2517 regval_data_p(val) );
2519 DEBUG(8,("specific: [%s], len: %d\n", regval_name(val), regval_size(val)));
2527 len += tdb_pack(buf+len, buflen-len, "p", NULL);
2533 /****************************************************************************
2534 Delete a printer - this just deletes the printer info file, any open
2535 handles are not affected.
2536 ****************************************************************************/
2538 uint32 del_a_printer(const char *sharename)
2541 char *printdb_path = NULL;
2542 TALLOC_CTX *ctx = talloc_tos();
2544 kbuf = make_printer_tdbkey(ctx, sharename);
2545 tdb_delete(tdb_printers, kbuf);
2547 kbuf= make_printers_secdesc_tdbkey(ctx, sharename);
2548 tdb_delete(tdb_printers, kbuf);
2550 close_all_print_db();
2552 if (geteuid() == 0) {
2553 if (asprintf(&printdb_path, "%s%s.tdb",
2554 cache_path("printing/"),
2558 unlink(printdb_path);
2559 SAFE_FREE(printdb_path);
2565 /****************************************************************************
2566 ****************************************************************************/
2567 static WERROR update_a_printer_2(NT_PRINTER_INFO_LEVEL_2 *info)
2573 TDB_DATA kbuf, dbuf;
2576 * in addprinter: no servername and the printer is the name
2577 * in setprinter: servername is \\server
2578 * and printer is \\server\\printer
2580 * Samba manages only local printers.
2581 * we currently don't support things like i
2582 * path=\\other_server\printer
2584 * We only store the printername, not \\server\printername
2587 if ( info->servername[0] != '\0' ) {
2588 trim_string(info->printername, info->servername, NULL);
2589 trim_char(info->printername, '\\', '\0');
2590 info->servername[0]='\0';
2594 * JFM: one day I'll forget.
2595 * below that's info->portname because that's the SAMBA sharename
2596 * and I made NT 'thinks' it's the portname
2597 * the info->sharename is the thing you can name when you add a printer
2598 * that's the short-name when you create shared printer for 95/98
2599 * So I've made a limitation in SAMBA: you can only have 1 printer model
2600 * behind a SAMBA share.
2608 len += tdb_pack(buf+len, buflen-len, "dddddddddddfffffPfffff",
2611 info->default_priority,
2628 info->printprocessor,
2632 len += pack_devicemode(info->devmode, buf+len, buflen-len);
2633 retlen = pack_values( info->data, buf+len, buflen-len );
2640 if (buflen != len) {
2641 buf = (uint8 *)SMB_REALLOC(buf, len);
2643 DEBUG(0,("update_a_printer_2: failed to enlarge buffer!\n"));
2651 kbuf = make_printer_tdbkey(talloc_tos(), info->sharename );
2656 ret = (tdb_store(tdb_printers, kbuf, dbuf, TDB_REPLACE) == 0? WERR_OK : WERR_NOMEM);
2659 if (!W_ERROR_IS_OK(ret))
2660 DEBUG(8, ("error updating printer to tdb on disk\n"));
2664 DEBUG(8,("packed printer [%s] with driver [%s] portname=[%s] len=%d\n",
2665 info->sharename, info->drivername, info->portname, len));
2671 /****************************************************************************
2672 Malloc and return an NT devicemode.
2673 ****************************************************************************/
2675 NT_DEVICEMODE *construct_nt_devicemode(const fstring default_devicename)
2678 char adevice[MAXDEVICENAME];
2679 NT_DEVICEMODE *nt_devmode = SMB_MALLOC_P(NT_DEVICEMODE);
2681 if (nt_devmode == NULL) {
2682 DEBUG(0,("construct_nt_devicemode: malloc fail.\n"));
2686 ZERO_STRUCTP(nt_devmode);
2688 slprintf(adevice, sizeof(adevice), "%s", default_devicename);
2689 fstrcpy(nt_devmode->devicename, adevice);
2691 fstrcpy(nt_devmode->formname, "Letter");
2693 nt_devmode->specversion = 0x0401;
2694 nt_devmode->driverversion = 0x0400;
2695 nt_devmode->size = 0x00DC;
2696 nt_devmode->driverextra = 0x0000;
2697 nt_devmode->fields = FORMNAME | TTOPTION | PRINTQUALITY |
2698 DEFAULTSOURCE | COPIES | SCALE |
2699 PAPERSIZE | ORIENTATION;
2700 nt_devmode->orientation = 1;
2701 nt_devmode->papersize = PAPER_LETTER;
2702 nt_devmode->paperlength = 0;
2703 nt_devmode->paperwidth = 0;
2704 nt_devmode->scale = 0x64;
2705 nt_devmode->copies = 1;
2706 nt_devmode->defaultsource = BIN_FORMSOURCE;
2707 nt_devmode->printquality = RES_HIGH; /* 0x0258 */
2708 nt_devmode->color = COLOR_MONOCHROME;
2709 nt_devmode->duplex = DUP_SIMPLEX;
2710 nt_devmode->yresolution = 0;
2711 nt_devmode->ttoption = TT_SUBDEV;
2712 nt_devmode->collate = COLLATE_FALSE;
2713 nt_devmode->icmmethod = 0;
2714 nt_devmode->icmintent = 0;
2715 nt_devmode->mediatype = 0;
2716 nt_devmode->dithertype = 0;
2718 /* non utilisés par un driver d'imprimante */
2719 nt_devmode->logpixels = 0;
2720 nt_devmode->bitsperpel = 0;
2721 nt_devmode->pelswidth = 0;
2722 nt_devmode->pelsheight = 0;
2723 nt_devmode->displayflags = 0;
2724 nt_devmode->displayfrequency = 0;
2725 nt_devmode->reserved1 = 0;
2726 nt_devmode->reserved2 = 0;
2727 nt_devmode->panningwidth = 0;
2728 nt_devmode->panningheight = 0;
2730 nt_devmode->nt_dev_private = NULL;
2734 /****************************************************************************
2735 Deepcopy an NT devicemode.
2736 ****************************************************************************/
2738 NT_DEVICEMODE *dup_nt_devicemode(NT_DEVICEMODE *nt_devicemode)
2740 NT_DEVICEMODE *new_nt_devicemode = NULL;
2742 if ( !nt_devicemode )
2745 if ((new_nt_devicemode = (NT_DEVICEMODE *)memdup(nt_devicemode, sizeof(NT_DEVICEMODE))) == NULL) {
2746 DEBUG(0,("dup_nt_devicemode: malloc fail.\n"));
2750 new_nt_devicemode->nt_dev_private = NULL;
2751 if (nt_devicemode->nt_dev_private != NULL) {
2752 if ((new_nt_devicemode->nt_dev_private = (uint8 *)memdup(nt_devicemode->nt_dev_private, nt_devicemode->driverextra)) == NULL) {
2753 SAFE_FREE(new_nt_devicemode);
2754 DEBUG(0,("dup_nt_devicemode: malloc fail.\n"));
2759 return new_nt_devicemode;
2762 /****************************************************************************
2763 Clean up and deallocate a (maybe partially) allocated NT_DEVICEMODE.
2764 ****************************************************************************/
2766 void free_nt_devicemode(NT_DEVICEMODE **devmode_ptr)
2768 NT_DEVICEMODE *nt_devmode = *devmode_ptr;
2770 if(nt_devmode == NULL)
2773 DEBUG(106,("free_nt_devicemode: deleting DEVMODE\n"));
2775 SAFE_FREE(nt_devmode->nt_dev_private);
2776 SAFE_FREE(*devmode_ptr);
2779 /****************************************************************************
2780 Clean up and deallocate a (maybe partially) allocated NT_PRINTER_INFO_LEVEL_2.
2781 ****************************************************************************/
2783 static void free_nt_printer_info_level_2(NT_PRINTER_INFO_LEVEL_2 **info_ptr)
2785 NT_PRINTER_INFO_LEVEL_2 *info = *info_ptr;
2790 free_nt_devicemode(&info->devmode);
2792 TALLOC_FREE( *info_ptr );
2796 /****************************************************************************
2797 ****************************************************************************/
2798 int unpack_devicemode(NT_DEVICEMODE **nt_devmode, const uint8 *buf, int buflen)
2802 NT_DEVICEMODE devmode;
2804 ZERO_STRUCT(devmode);
2806 len += tdb_unpack(buf+len, buflen-len, "p", nt_devmode);
2808 if (!*nt_devmode) return len;
2810 len += tdb_unpack(buf+len, buflen-len, "ffwwwwwwwwwwwwwwwwwwddddddddddddddp",
2814 &devmode.specversion,
2815 &devmode.driverversion,
2817 &devmode.driverextra,
2818 &devmode.orientation,
2820 &devmode.paperlength,
2821 &devmode.paperwidth,
2824 &devmode.defaultsource,
2825 &devmode.printquality,
2828 &devmode.yresolution,
2834 &devmode.bitsperpel,
2836 &devmode.pelsheight,
2837 &devmode.displayflags,
2838 &devmode.displayfrequency,
2842 &devmode.dithertype,
2845 &devmode.panningwidth,
2846 &devmode.panningheight,
2847 &devmode.nt_dev_private);
2849 if (devmode.nt_dev_private) {
2850 /* the len in tdb_unpack is an int value and
2851 * devmode.driverextra is only a short
2853 len += tdb_unpack(buf+len, buflen-len, "B", &extra_len, &devmode.nt_dev_private);
2854 devmode.driverextra=(uint16)extra_len;
2856 /* check to catch an invalid TDB entry so we don't segfault */
2857 if (devmode.driverextra == 0) {
2858 devmode.nt_dev_private = NULL;
2862 *nt_devmode = (NT_DEVICEMODE *)memdup(&devmode, sizeof(devmode));
2864 SAFE_FREE(devmode.nt_dev_private);
2868 DEBUG(8,("Unpacked devicemode [%s](%s)\n", devmode.devicename, devmode.formname));
2869 if (devmode.nt_dev_private)
2870 DEBUG(8,("with a private section of %d bytes\n", devmode.driverextra));
2875 /****************************************************************************
2876 Allocate and initialize a new slot.
2877 ***************************************************************************/
2879 int add_new_printer_key( NT_PRINTER_DATA *data, const char *name )
2884 if ( !name || !data )
2887 /* allocate another slot in the NT_PRINTER_KEY array */
2889 if ( !(d = TALLOC_REALLOC_ARRAY( data, data->keys, NT_PRINTER_KEY, data->num_keys+1)) ) {
2890 DEBUG(0,("add_new_printer_key: Realloc() failed!\n"));
2896 key_index = data->num_keys;
2898 /* initialze new key */
2900 data->keys[key_index].name = talloc_strdup( data, name );
2902 if ( !(data->keys[key_index].values = TALLOC_ZERO_P( data, REGVAL_CTR )) )
2907 DEBUG(10,("add_new_printer_key: Inserted new data key [%s]\n", name ));
2912 /****************************************************************************
2913 search for a registry key name in the existing printer data
2914 ***************************************************************************/
2916 int delete_printer_key( NT_PRINTER_DATA *data, const char *name )
2920 for ( i=0; i<data->num_keys; i++ ) {
2921 if ( strequal( data->keys[i].name, name ) ) {
2923 /* cleanup memory */
2925 TALLOC_FREE( data->keys[i].name );
2926 TALLOC_FREE( data->keys[i].values );
2928 /* if not the end of the array, move remaining elements down one slot */
2931 if ( data->num_keys && (i < data->num_keys) )
2932 memmove( &data->keys[i], &data->keys[i+1], sizeof(NT_PRINTER_KEY)*(data->num_keys-i) );
2939 return data->num_keys;
2942 /****************************************************************************
2943 search for a registry key name in the existing printer data
2944 ***************************************************************************/
2946 int lookup_printerkey( NT_PRINTER_DATA *data, const char *name )
2951 if ( !data || !name )
2954 DEBUG(12,("lookup_printerkey: Looking for [%s]\n", name));
2956 /* loop over all existing keys */
2958 for ( i=0; i<data->num_keys; i++ ) {
2959 if ( strequal(data->keys[i].name, name) ) {
2960 DEBUG(12,("lookup_printerkey: Found [%s]!\n", name));
2970 /****************************************************************************
2971 ***************************************************************************/
2973 int get_printer_subkeys( NT_PRINTER_DATA *data, const char* key, fstring **subkeys )
2977 int num_subkeys = 0;
2979 fstring *subkeys_ptr = NULL;
2990 /* special case of asking for the top level printer data registry key names */
2992 if ( strlen(key) == 0 ) {
2993 for ( i=0; i<data->num_keys; i++ ) {
2995 /* found a match, so allocate space and copy the name */
2997 if ( !(subkeys_ptr = SMB_REALLOC_ARRAY( subkeys_ptr, fstring, num_subkeys+2)) ) {
2998 DEBUG(0,("get_printer_subkeys: Realloc failed for [%d] entries!\n",
3003 fstrcpy( subkeys_ptr[num_subkeys], data->keys[i].name );
3010 /* asking for the subkeys of some key */
3011 /* subkey paths are stored in the key name using '\' as the delimiter */
3013 for ( i=0; i<data->num_keys; i++ ) {
3014 if ( StrnCaseCmp(data->keys[i].name, key, strlen(key)) == 0 ) {
3016 /* if we found the exact key, then break */
3017 key_len = strlen( key );
3018 if ( strlen(data->keys[i].name) == key_len )
3021 /* get subkey path */
3023 p = data->keys[i].name + key_len;
3026 fstrcpy( subkeyname, p );
3027 if ( (p = strchr( subkeyname, '\\' )) )
3030 /* don't add a key more than once */
3032 for ( j=0; j<num_subkeys; j++ ) {
3033 if ( strequal( subkeys_ptr[j], subkeyname ) )
3037 if ( j != num_subkeys )
3040 /* found a match, so allocate space and copy the name */
3042 if ( !(subkeys_ptr = SMB_REALLOC_ARRAY( subkeys_ptr, fstring, num_subkeys+2)) ) {
3043 DEBUG(0,("get_printer_subkeys: Realloc failed for [%d] entries!\n",
3048 fstrcpy( subkeys_ptr[num_subkeys], subkeyname );
3054 /* return error if the key was not found */
3056 if ( i == data->num_keys ) {
3057 SAFE_FREE(subkeys_ptr);
3062 /* tag off the end */
3065 fstrcpy(subkeys_ptr[num_subkeys], "" );
3067 *subkeys = subkeys_ptr;
3073 static void map_sz_into_ctr(REGVAL_CTR *ctr, const char *val_name,
3076 smb_ucs2_t conv_str[1024];
3079 regval_ctr_delvalue(ctr, val_name);
3080 str_size = push_ucs2(NULL, conv_str, sz, sizeof(conv_str),
3081 STR_TERMINATE | STR_NOALIGN);
3082 regval_ctr_addvalue(ctr, val_name, REG_SZ,
3083 (char *) conv_str, str_size);
3086 static void map_dword_into_ctr(REGVAL_CTR *ctr, const char *val_name,
3089 regval_ctr_delvalue(ctr, val_name);
3090 regval_ctr_addvalue(ctr, val_name, REG_DWORD,
3091 (char *) &dword, sizeof(dword));
3094 static void map_bool_into_ctr(REGVAL_CTR *ctr, const char *val_name,
3097 uint8 bin_bool = (b ? 1 : 0);
3098 regval_ctr_delvalue(ctr, val_name);
3099 regval_ctr_addvalue(ctr, val_name, REG_BINARY,
3100 (char *) &bin_bool, sizeof(bin_bool));
3103 static void map_single_multi_sz_into_ctr(REGVAL_CTR *ctr, const char *val_name,
3104 const char *multi_sz)
3106 smb_ucs2_t *conv_strs = NULL;
3109 /* a multi-sz has to have a null string terminator, i.e., the last
3110 string must be followed by two nulls */
3111 str_size = strlen(multi_sz) + 2;
3112 conv_strs = SMB_CALLOC_ARRAY(smb_ucs2_t, str_size);
3117 /* Change to byte units. */
3118 str_size *= sizeof(smb_ucs2_t);
3119 push_ucs2(NULL, conv_strs, multi_sz, str_size,
3120 STR_TERMINATE | STR_NOALIGN);
3122 regval_ctr_delvalue(ctr, val_name);
3123 regval_ctr_addvalue(ctr, val_name, REG_MULTI_SZ,
3124 (char *) conv_strs, str_size);
3125 SAFE_FREE(conv_strs);
3128 /****************************************************************************
3129 * Map the NT_PRINTER_INFO_LEVEL_2 data into DsSpooler keys for publishing.
3131 * @param info2 NT_PRINTER_INFO_LEVEL_2 describing printer - gets modified
3132 * @return bool indicating success or failure
3133 ***************************************************************************/
3135 static bool map_nt_printer_info2_to_dsspooler(NT_PRINTER_INFO_LEVEL_2 *info2)
3137 REGVAL_CTR *ctr = NULL;
3139 const char *dnssuffix;
3140 char *allocated_string = NULL;
3141 const char *ascii_str;
3144 if ((i = lookup_printerkey(info2->data, SPOOL_DSSPOOLER_KEY)) < 0)
3145 i = add_new_printer_key(info2->data, SPOOL_DSSPOOLER_KEY);
3146 ctr = info2->data->keys[i].values;
3148 map_sz_into_ctr(ctr, SPOOL_REG_PRINTERNAME, info2->sharename);
3149 map_sz_into_ctr(ctr, SPOOL_REG_SHORTSERVERNAME, global_myname());
3151 /* we make the assumption that the netbios name is the same
3152 as the DNS name sinc ethe former will be what we used to
3155 dnssuffix = get_mydnsdomname(talloc_tos());
3156 if (dnssuffix && *dnssuffix) {
3157 fstr_sprintf( longname, "%s.%s", global_myname(), dnssuffix );
3159 fstrcpy( longname, global_myname() );
3162 map_sz_into_ctr(ctr, SPOOL_REG_SERVERNAME, longname);
3164 if (asprintf(&allocated_string, "\\\\%s\\%s", longname, info2->sharename) == -1) {
3167 map_sz_into_ctr(ctr, SPOOL_REG_UNCNAME, allocated_string);
3168 SAFE_FREE(allocated_string);
3170 map_dword_into_ctr(ctr, SPOOL_REG_VERSIONNUMBER, 4);
3171 map_sz_into_ctr(ctr, SPOOL_REG_DRIVERNAME, info2->drivername);
3172 map_sz_into_ctr(ctr, SPOOL_REG_LOCATION, info2->location);
3173 map_sz_into_ctr(ctr, SPOOL_REG_DESCRIPTION, info2->comment);
3174 map_single_multi_sz_into_ctr(ctr, SPOOL_REG_PORTNAME, info2->portname);
3175 map_sz_into_ctr(ctr, SPOOL_REG_PRINTSEPARATORFILE, info2->sepfile);
3176 map_dword_into_ctr(ctr, SPOOL_REG_PRINTSTARTTIME, info2->starttime);
3177 map_dword_into_ctr(ctr, SPOOL_REG_PRINTENDTIME, info2->untiltime);
3178 map_dword_into_ctr(ctr, SPOOL_REG_PRIORITY, info2->priority);
3180 map_bool_into_ctr(ctr, SPOOL_REG_PRINTKEEPPRINTEDJOBS,
3181 (info2->attributes &
3182 PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS));
3184 switch (info2->attributes & 0x3) {
3186 ascii_str = SPOOL_REGVAL_PRINTWHILESPOOLING;
3189 ascii_str = SPOOL_REGVAL_PRINTAFTERSPOOLED;
3192 ascii_str = SPOOL_REGVAL_PRINTDIRECT;
3195 ascii_str = "unknown";
3197 map_sz_into_ctr(ctr, SPOOL_REG_PRINTSPOOLING, ascii_str);
3202 /*****************************************************************
3203 ****************************************************************/
3205 static void store_printer_guid(NT_PRINTER_INFO_LEVEL_2 *info2,
3209 REGVAL_CTR *ctr=NULL;
3210 UNISTR2 unistr_guid;
3212 /* find the DsSpooler key */
3213 if ((i = lookup_printerkey(info2->data, SPOOL_DSSPOOLER_KEY)) < 0)
3214 i = add_new_printer_key(info2->data, SPOOL_DSSPOOLER_KEY);
3215 ctr = info2->data->keys[i].values;
3217 regval_ctr_delvalue(ctr, "objectGUID");
3219 /* We used to store this as a REG_BINARY but that causes
3222 ZERO_STRUCT( unistr_guid );
3224 init_unistr2( &unistr_guid, GUID_string(talloc_tos(), &guid),
3225 UNI_STR_TERMINATE );
3227 regval_ctr_addvalue(ctr, "objectGUID", REG_SZ,
3228 (char *)unistr_guid.buffer,
3229 unistr_guid.uni_max_len*2);
3233 static WERROR nt_printer_publish_ads(ADS_STRUCT *ads,
3234 NT_PRINTER_INFO_LEVEL *printer)
3238 char *prt_dn = NULL, *srv_dn, *srv_cn_0, *srv_cn_escaped, *sharename_escaped;
3239 char *srv_dn_utf8, **srv_cn_utf8;
3242 const char *attrs[] = {"objectGUID", NULL};
3244 WERROR win_rc = WERR_OK;
3245 size_t converted_size;
3248 DEBUG(5, ("publishing printer %s\n", printer->info_2->printername));
3250 /* figure out where to publish */
3251 ads_find_machine_acct(ads, &res, global_myname());
3253 /* We use ldap_get_dn here as we need the answer
3254 * in utf8 to call ldap_explode_dn(). JRA. */
3256 srv_dn_utf8 = ldap_get_dn((LDAP *)ads->ldap.ld, (LDAPMessage *)res);
3258 return WERR_SERVER_UNAVAILABLE;
3260 ads_msgfree(ads, res);
3261 srv_cn_utf8 = ldap_explode_dn(srv_dn_utf8, 1);
3263 ldap_memfree(srv_dn_utf8);
3264 return WERR_SERVER_UNAVAILABLE;
3266 /* Now convert to CH_UNIX. */
3267 if (!pull_utf8_allocate(&srv_dn, srv_dn_utf8, &converted_size)) {
3268 ldap_memfree(srv_dn_utf8);
3269 ldap_memfree(srv_cn_utf8);
3270 return WERR_SERVER_UNAVAILABLE;
3272 if (!pull_utf8_allocate(&srv_cn_0, srv_cn_utf8[0], &converted_size)) {
3273 ldap_memfree(srv_dn_utf8);
3274 ldap_memfree(srv_cn_utf8);
3276 return WERR_SERVER_UNAVAILABLE;
3279 ldap_memfree(srv_dn_utf8);
3280 ldap_memfree(srv_cn_utf8);
3282 srv_cn_escaped = escape_rdn_val_string_alloc(srv_cn_0);
3283 if (!srv_cn_escaped) {
3284 SAFE_FREE(srv_cn_0);
3286 return WERR_SERVER_UNAVAILABLE;
3288 sharename_escaped = escape_rdn_val_string_alloc(printer->info_2->sharename);
3289 if (!sharename_escaped) {
3290 SAFE_FREE(srv_cn_escaped);
3291 SAFE_FREE(srv_cn_0);
3293 return WERR_SERVER_UNAVAILABLE;
3296 ret = asprintf(&prt_dn, "cn=%s-%s,%s", srv_cn_escaped, sharename_escaped, srv_dn);
3299 SAFE_FREE(srv_cn_0);
3300 SAFE_FREE(srv_cn_escaped);
3301 SAFE_FREE(sharename_escaped);
3307 /* build the ads mods */
3308 ctx = talloc_init("nt_printer_publish_ads");
3314 mods = ads_init_mods(ctx);
3318 talloc_destroy(ctx);
3322 get_local_printer_publishing_data(ctx, &mods, printer->info_2->data);
3323 ads_mod_str(ctx, &mods, SPOOL_REG_PRINTERNAME,
3324 printer->info_2->sharename);
3327 ads_rc = ads_mod_printer_entry(ads, prt_dn, ctx, &mods);
3328 if (ads_rc.err.rc == LDAP_NO_SUCH_OBJECT) {
3330 for (i=0; mods[i] != 0; i++)
3332 mods[i] = (LDAPMod *)-1;
3333 ads_rc = ads_add_printer_entry(ads, prt_dn, ctx, &mods);
3336 if (!ADS_ERR_OK(ads_rc))
3337 DEBUG(3, ("error publishing %s: %s\n", printer->info_2->sharename, ads_errstr(ads_rc)));
3339 talloc_destroy(ctx);
3341 /* retreive the guid and store it locally */
3342 if (ADS_ERR_OK(ads_search_dn(ads, &res, prt_dn, attrs))) {
3344 ads_pull_guid(ads, res, &guid);
3345 ads_msgfree(ads, res);
3346 store_printer_guid(printer->info_2, guid);
3347 win_rc = mod_a_printer(printer, 2);
3354 static WERROR nt_printer_unpublish_ads(ADS_STRUCT *ads,
3355 NT_PRINTER_INFO_LEVEL *printer)
3358 LDAPMessage *res = NULL;
3359 char *prt_dn = NULL;
3361 DEBUG(5, ("unpublishing printer %s\n", printer->info_2->printername));
3363 /* remove the printer from the directory */
3364 ads_rc = ads_find_printer_on_server(ads, &res,
3365 printer->info_2->sharename, global_myname());
3367 if (ADS_ERR_OK(ads_rc) && res && ads_count_replies(ads, res)) {
3368 prt_dn = ads_get_dn(ads, res);
3370 ads_msgfree(ads, res);
3373 ads_rc = ads_del_dn(ads, prt_dn);
3374 ads_memfree(ads, prt_dn);
3378 ads_msgfree(ads, res);
3383 /****************************************************************************
3384 * Publish a printer in the directory
3386 * @param snum describing printer service
3387 * @return WERROR indicating status of publishing
3388 ***************************************************************************/
3390 WERROR nt_printer_publish(Printer_entry *print_hnd, int snum, int action)
3393 ADS_STRUCT *ads = NULL;
3394 NT_PRINTER_INFO_LEVEL *printer = NULL;
3397 win_rc = get_a_printer(print_hnd, &printer, 2, lp_servicename(snum));
3398 if (!W_ERROR_IS_OK(win_rc))
3402 case DSPRINT_PUBLISH:
3403 case DSPRINT_UPDATE:
3404 /* set the DsSpooler info and attributes */
3405 if (!(map_nt_printer_info2_to_dsspooler(printer->info_2))) {
3406 win_rc = WERR_NOMEM;
3410 printer->info_2->attributes |= PRINTER_ATTRIBUTE_PUBLISHED;
3412 case DSPRINT_UNPUBLISH:
3413 printer->info_2->attributes ^= PRINTER_ATTRIBUTE_PUBLISHED;
3416 win_rc = WERR_NOT_SUPPORTED;
3420 win_rc = mod_a_printer(printer, 2);
3421 if (!W_ERROR_IS_OK(win_rc)) {
3422 DEBUG(3, ("err %d saving data\n", W_ERROR_V(win_rc)));
3426 ads = ads_init(lp_realm(), lp_workgroup(), NULL);
3428 DEBUG(3, ("ads_init() failed\n"));
3429 win_rc = WERR_SERVER_UNAVAILABLE;
3432 setenv(KRB5_ENV_CCNAME, "MEMORY:prtpub_cache", 1);
3433 SAFE_FREE(ads->auth.password);
3434 ads->auth.password = secrets_fetch_machine_password(lp_workgroup(),
3437 /* ads_connect() will find the DC for us */
3438 ads_rc = ads_connect(ads);
3439 if (!ADS_ERR_OK(ads_rc)) {
3440 DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_rc)));
3441 win_rc = WERR_ACCESS_DENIED;
3446 case DSPRINT_PUBLISH:
3447 case DSPRINT_UPDATE:
3448 win_rc = nt_printer_publish_ads(ads, printer);
3450 case DSPRINT_UNPUBLISH:
3451 win_rc = nt_printer_unpublish_ads(ads, printer);
3456 free_a_printer(&printer, 2);
3461 WERROR check_published_printers(void)
3464 ADS_STRUCT *ads = NULL;
3466 int n_services = lp_numservices();
3467 NT_PRINTER_INFO_LEVEL *printer = NULL;
3469 ads = ads_init(lp_realm(), lp_workgroup(), NULL);
3471 DEBUG(3, ("ads_init() failed\n"));
3472 return WERR_SERVER_UNAVAILABLE;
3474 setenv(KRB5_ENV_CCNAME, "MEMORY:prtpub_cache", 1);
3475 SAFE_FREE(ads->auth.password);
3476 ads->auth.password = secrets_fetch_machine_password(lp_workgroup(),
3479 /* ads_connect() will find the DC for us */
3480 ads_rc = ads_connect(ads);
3481 if (!ADS_ERR_OK(ads_rc)) {
3482 DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_rc)));
3484 ads_kdestroy("MEMORY:prtpub_cache");
3485 return WERR_ACCESS_DENIED;
3488 for (snum = 0; snum < n_services; snum++) {
3489 if (!(lp_snum_ok(snum) && lp_print_ok(snum)))
3492 if (W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2,
3493 lp_servicename(snum))) &&
3494 (printer->info_2->attributes & PRINTER_ATTRIBUTE_PUBLISHED))
3495 nt_printer_publish_ads(ads, printer);
3497 free_a_printer(&printer, 2);
3501 ads_kdestroy("MEMORY:prtpub_cache");
3505 bool is_printer_published(Printer_entry *print_hnd, int snum,
3508 NT_PRINTER_INFO_LEVEL *printer = NULL;
3510 REGISTRY_VALUE *guid_val;
3515 win_rc = get_a_printer(print_hnd, &printer, 2, lp_servicename(snum));
3517 if (!W_ERROR_IS_OK(win_rc) ||
3518 !(printer->info_2->attributes & PRINTER_ATTRIBUTE_PUBLISHED) ||
3519 ((i = lookup_printerkey(printer->info_2->data, SPOOL_DSSPOOLER_KEY)) < 0) ||
3520 !(ctr = printer->info_2->data->keys[i].values) ||
3521 !(guid_val = regval_ctr_getvalue(ctr, "objectGUID")))
3523 free_a_printer(&printer, 2);
3527 /* fetching printer guids really ought to be a separate function. */
3532 /* We used to store the guid as REG_BINARY, then swapped
3533 to REG_SZ for Vista compatibility so check for both */
3535 switch ( regval_type(guid_val) ){
3537 rpcstr_pull( guid_str, regval_data_p(guid_val),
3538 sizeof(guid_str)-1, -1, STR_TERMINATE );
3539 ret = NT_STATUS_IS_OK(GUID_from_string( guid_str, guid ));
3542 if ( regval_size(guid_val) != sizeof(struct GUID) ) {
3546 memcpy(guid, regval_data_p(guid_val), sizeof(struct GUID));
3549 DEBUG(0,("is_printer_published: GUID value stored as "
3550 "invaluid type (%d)\n", regval_type(guid_val) ));
3555 free_a_printer(&printer, 2);
3559 WERROR nt_printer_publish(Printer_entry *print_hnd, int snum, int action)
3564 WERROR check_published_printers(void)
3569 bool is_printer_published(Printer_entry *print_hnd, int snum,
3574 #endif /* HAVE_ADS */
3576 /****************************************************************************
3577 ***************************************************************************/
3579 WERROR delete_all_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key )
3581 NT_PRINTER_DATA *data;
3583 int removed_keys = 0;
3587 empty_slot = data->num_keys;
3590 return WERR_INVALID_PARAM;
3592 /* remove all keys */
3594 if ( !strlen(key) ) {
3596 TALLOC_FREE( data );
3600 DEBUG(8,("delete_all_printer_data: Removed all Printer Data from printer [%s]\n",
3606 /* remove a specific key (and all subkeys) */
3608 for ( i=0; i<data->num_keys; i++ ) {
3609 if ( StrnCaseCmp( data->keys[i].name, key, strlen(key)) == 0 ) {
3610 DEBUG(8,("delete_all_printer_data: Removed all Printer Data from key [%s]\n",
3611 data->keys[i].name));
3613 TALLOC_FREE( data->keys[i].name );
3614 TALLOC_FREE( data->keys[i].values );
3616 /* mark the slot as empty */
3618 ZERO_STRUCTP( &data->keys[i] );
3622 /* find the first empty slot */
3624 for ( i=0; i<data->num_keys; i++ ) {
3625 if ( !data->keys[i].name ) {
3632 if ( i == data->num_keys )
3633 /* nothing was removed */
3634 return WERR_INVALID_PARAM;
3636 /* move everything down */
3638 for ( i=empty_slot+1; i<data->num_keys; i++ ) {
3639 if ( data->keys[i].name ) {
3640 memcpy( &data->keys[empty_slot], &data->keys[i], sizeof(NT_PRINTER_KEY) );
3641 ZERO_STRUCTP( &data->keys[i] );
3649 data->num_keys -= removed_keys;
3651 /* sanity check to see if anything is left */
3653 if ( !data->num_keys ) {
3654 DEBUG(8,("delete_all_printer_data: No keys left for printer [%s]\n", p2->printername ));
3656 SAFE_FREE( data->keys );
3657 ZERO_STRUCTP( data );
3663 /****************************************************************************
3664 ***************************************************************************/
3666 WERROR delete_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value )
3668 WERROR result = WERR_OK;
3671 /* we must have names on non-zero length */
3673 if ( !key || !*key|| !value || !*value )
3674 return WERR_INVALID_NAME;
3676 /* find the printer key first */
3678 key_index = lookup_printerkey( p2->data, key );
3679 if ( key_index == -1 )
3682 /* make sure the value exists so we can return the correct error code */
3684 if ( !regval_ctr_getvalue( p2->data->keys[key_index].values, value ) )
3685 return WERR_BADFILE;
3687 regval_ctr_delvalue( p2->data->keys[key_index].values, value );
3689 DEBUG(8,("delete_printer_data: Removed key => [%s], value => [%s]\n",
3695 /****************************************************************************
3696 ***************************************************************************/
3698 WERROR add_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value,
3699 uint32 type, uint8 *data, int real_len )
3701 WERROR result = WERR_OK;
3704 /* we must have names on non-zero length */
3706 if ( !key || !*key|| !value || !*value )
3707 return WERR_INVALID_NAME;
3709 /* find the printer key first */
3711 key_index = lookup_printerkey( p2->data, key );
3712 if ( key_index == -1 )
3713 key_index = add_new_printer_key( p2->data, key );
3715 if ( key_index == -1 )
3718 regval_ctr_addvalue( p2->data->keys[key_index].values, value,
3719 type, (const char *)data, real_len );
3721 DEBUG(8,("add_printer_data: Added key => [%s], value => [%s], type=> [%d], size => [%d]\n",
3722 key, value, type, real_len ));
3727 /****************************************************************************
3728 ***************************************************************************/
3730 REGISTRY_VALUE* get_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value )
3734 if ( (key_index = lookup_printerkey( p2->data, key )) == -1 )
3737 DEBUG(8,("get_printer_data: Attempting to lookup key => [%s], value => [%s]\n",
3740 return regval_ctr_getvalue( p2->data->keys[key_index].values, value );
3743 /****************************************************************************
3744 Unpack a list of registry values frem the TDB
3745 ***************************************************************************/
3747 static int unpack_values(NT_PRINTER_DATA *printer_data, const uint8 *buf, int buflen)
3752 const char *valuename = NULL;
3753 const char *keyname = NULL;
3757 REGISTRY_VALUE *regval_p;
3760 /* add the "PrinterDriverData" key first for performance reasons */
3762 add_new_printer_key( printer_data, SPOOL_PRINTERDATA_KEY );
3764 /* loop and unpack the rest of the registry values */
3768 /* check to see if there are any more registry values */
3771 len += tdb_unpack(buf+len, buflen-len, "p", ®val_p);
3775 /* unpack the next regval */
3777 len += tdb_unpack(buf+len, buflen-len, "fdB",
3783 /* lookup for subkey names which have a type of REG_NONE */
3784 /* there's no data with this entry */
3786 if ( type == REG_NONE ) {
3787 if ( (key_index=lookup_printerkey( printer_data, string)) == -1 )
3788 add_new_printer_key( printer_data, string );
3793 * break of the keyname from the value name.
3794 * Valuenames can have embedded '\'s so be careful.
3795 * only support one level of keys. See the
3796 * "Konica Fiery S300 50C-K v1.1. enu" 2k driver.
3800 str = strchr_m( string, '\\');
3802 /* Put in "PrinterDriverData" is no key specified */
3805 keyname = SPOOL_PRINTERDATA_KEY;
3814 /* see if we need a new key */
3816 if ( (key_index=lookup_printerkey( printer_data, keyname )) == -1 )
3817 key_index = add_new_printer_key( printer_data, keyname );
3819 if ( key_index == -1 ) {
3820 DEBUG(0,("unpack_values: Failed to allocate a new key [%s]!\n",
3825 DEBUG(8,("specific: [%s:%s], len: %d\n", keyname, valuename, size));
3827 /* Vista doesn't like unknown REG_BINARY values in DsSpooler.
3828 Thanks to Martin Zielinski for the hint. */
3830 if ( type == REG_BINARY &&
3831 strequal( keyname, SPOOL_DSSPOOLER_KEY ) &&
3832 strequal( valuename, "objectGUID" ) )
3835 UNISTR2 unistr_guid;
3837 ZERO_STRUCT( unistr_guid );
3839 /* convert the GUID to a UNICODE string */
3841 memcpy( &guid, data_p, sizeof(struct GUID) );
3843 init_unistr2( &unistr_guid,
3844 GUID_string(talloc_tos(), &guid),
3845 UNI_STR_TERMINATE );
3847 regval_ctr_addvalue( printer_data->keys[key_index].values,
3849 (const char *)unistr_guid.buffer,
3850 unistr_guid.uni_str_len*2 );
3855 regval_ctr_addvalue( printer_data->keys[key_index].values,
3856 valuename, type, (const char *)data_p,
3860 SAFE_FREE(data_p); /* 'B' option to tdbpack does a malloc() */
3867 /****************************************************************************
3868 ***************************************************************************/
3870 static char *last_from;
3871 static char *last_to;
3873 static const char *get_last_from(void)
3881 static const char *get_last_to(void)
3889 static bool set_last_from_to(const char *from, const char *to)
3891 char *orig_from = last_from;
3892 char *orig_to = last_to;
3894 last_from = SMB_STRDUP(from);
3895 last_to = SMB_STRDUP(to);
3897 SAFE_FREE(orig_from);
3900 if (!last_from || !last_to) {
3901 SAFE_FREE(last_from);
3908 static void map_to_os2_driver(fstring drivername)
3910 char *mapfile = lp_os2_driver_map();
3911 char **lines = NULL;
3915 if (!strlen(drivername))
3921 if (strequal(drivername,get_last_from())) {
3922 DEBUG(3,("Mapped Windows driver %s to OS/2 driver %s\n",
3923 drivername,get_last_to()));
3924 fstrcpy(drivername,get_last_to());
3928 lines = file_lines_load(mapfile, &numlines,0,NULL);
3929 if (numlines == 0 || lines == NULL) {
3930 DEBUG(0,("No entries in OS/2 driver map %s\n",mapfile));
3935 DEBUG(4,("Scanning OS/2 driver map %s\n",mapfile));
3937 for( i = 0; i < numlines; i++) {
3938 char *nt_name = lines[i];
3939 char *os2_name = strchr(nt_name,'=');
3946 while (isspace(*nt_name))
3949 if (!*nt_name || strchr("#;",*nt_name))
3953 int l = strlen(nt_name);
3954 while (l && isspace(nt_name[l-1])) {
3960 while (isspace(*os2_name))
3964 int l = strlen(os2_name);
3965 while (l && isspace(os2_name[l-1])) {
3971 if (strequal(nt_name,drivername)) {
3972 DEBUG(3,("Mapped windows driver %s to os2 driver%s\n",drivername,os2_name));
3973 set_last_from_to(drivername,os2_name);
3974 fstrcpy(drivername,os2_name);
3983 /****************************************************************************
3984 Get a default printer info 2 struct.
3985 ****************************************************************************/
3987 static WERROR get_a_printer_2_default(NT_PRINTER_INFO_LEVEL_2 *info,
3988 const char *servername,
3989 const char* sharename,
3992 int snum = lp_servicenumber(sharename);
3994 slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", servername);
3995 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
3996 servername, sharename);
3997 fstrcpy(info->sharename, sharename);
3998 fstrcpy(info->portname, SAMBA_PRINTER_PORT_NAME);
4000 /* by setting the driver name to an empty string, a local NT admin
4001 can now run the **local** APW to install a local printer driver
4002 for a Samba shared printer in 2.2. Without this, drivers **must** be
4003 installed on the Samba server for NT clients --jerry */
4004 #if 0 /* JERRY --do not uncomment-- */
4005 if (!*info->drivername)
4006 fstrcpy(info->drivername, "NO DRIVER AVAILABLE FOR THIS PRINTER");
4010 DEBUG(10,("get_a_printer_2_default: driver name set to [%s]\n", info->drivername));
4012 strlcpy(info->comment, "", sizeof(info->comment));
4013 fstrcpy(info->printprocessor, "winprint");
4014 fstrcpy(info->datatype, "RAW");
4017 if (get_loc_com && (enum printing_types)lp_printing(snum) == PRINT_CUPS ) {
4018 /* Pull the location and comment strings from cups if we don't
4020 if ( !strlen(info->location) || !strlen(info->comment) )
4021 cups_pull_comment_location( info );
4025 info->attributes = PRINTER_ATTRIBUTE_SAMBA;
4027 info->starttime = 0; /* Minutes since 12:00am GMT */
4028 info->untiltime = 0; /* Minutes since 12:00am GMT */
4030 info->default_priority = 1;
4031 info->setuptime = (uint32)time(NULL);
4034 * I changed this as I think it is better to have a generic
4035 * DEVMODE than to crash Win2k explorer.exe --jerry
4036 * See the HP Deskjet 990c Win2k drivers for an example.
4038 * However the default devmode appears to cause problems
4039 * with the HP CLJ 8500 PCL driver. Hence the addition of
4040 * the "default devmode" parameter --jerry 22/01/2002
4043 if (lp_default_devmode(snum)) {
4044 if ((info->devmode = construct_nt_devicemode(info->printername)) == NULL) {
4048 info->devmode = NULL;
4051 if (!nt_printing_getsec(info, sharename, &info->secdesc_buf)) {
4059 free_nt_devicemode(&info->devmode);
4061 return WERR_ACCESS_DENIED;
4064 /****************************************************************************
4065 ****************************************************************************/
4067 static WERROR get_a_printer_2(NT_PRINTER_INFO_LEVEL_2 *info,
4068 const char *servername,
4069 const char *sharename,
4073 int snum = lp_servicenumber(sharename);
4074 TDB_DATA kbuf, dbuf;
4075 fstring printername;
4076 char adevice[MAXDEVICENAME];
4077 char *comment = NULL;
4079 kbuf = make_printer_tdbkey(talloc_tos(), sharename);
4081 dbuf = tdb_fetch(tdb_printers, kbuf);
4083 return get_a_printer_2_default(info, servername,
4084 sharename, get_loc_com);
4087 len += tdb_unpack(dbuf.dptr+len, dbuf.dsize-len, "dddddddddddfffffPfffff",
4090 &info->default_priority,
4097 &info->c_setprinter,
4107 info->printprocessor,
4112 strlcpy(info->comment, comment, sizeof(info->comment));
4116 /* Samba has to have shared raw drivers. */
4117 info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
4118 info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
4120 /* Restore the stripped strings. */
4121 slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", servername);
4123 if ( lp_force_printername(snum) ) {
4124 slprintf(printername, sizeof(printername)-1, "\\\\%s\\%s", servername, sharename );
4126 slprintf(printername, sizeof(printername)-1, "\\\\%s\\%s", servername, info->printername);
4129 fstrcpy(info->printername, printername);
4132 if (get_loc_com && (enum printing_types)lp_printing(snum) == PRINT_CUPS ) {
4133 /* Pull the location and comment strings from cups if we don't
4135 if ( !strlen(info->location) || !strlen(info->comment) )
4136 cups_pull_comment_location( info );
4140 len += unpack_devicemode(&info->devmode,dbuf.dptr+len, dbuf.dsize-len);
4143 * Some client drivers freak out if there is a NULL devmode
4144 * (probably the driver is not checking before accessing
4145 * the devmode pointer) --jerry
4147 * See comments in get_a_printer_2_default()
4150 if (lp_default_devmode(snum) && !info->devmode) {
4151 DEBUG(8,("get_a_printer_2: Constructing a default device mode for [%s]\n",
4153 info->devmode = construct_nt_devicemode(printername);
4156 slprintf( adevice, sizeof(adevice), "%s", info->printername );
4157 if (info->devmode) {
4158 fstrcpy(info->devmode->devicename, adevice);
4161 if ( !(info->data = TALLOC_ZERO_P( info, NT_PRINTER_DATA )) ) {
4162 DEBUG(0,("unpack_values: talloc() failed!\n"));
4163 SAFE_FREE(dbuf.dptr);
4166 len += unpack_values( info->data, dbuf.dptr+len, dbuf.dsize-len );
4168 /* This will get the current RPC talloc context, but we should be
4169 passing this as a parameter... fixme... JRA ! */
4171 if (!nt_printing_getsec(info, sharename, &info->secdesc_buf)) {
4172 SAFE_FREE(dbuf.dptr);
4176 /* Fix for OS/2 drivers. */
4178 if (get_remote_arch() == RA_OS2) {
4179 map_to_os2_driver(info->drivername);
4182 SAFE_FREE(dbuf.dptr);
4184 DEBUG(9,("Unpacked printer [%s] name [%s] running driver [%s]\n",
4185 sharename, info->printername, info->drivername));
4190 /****************************************************************************
4191 Debugging function, dump at level 6 the struct in the logs.
4192 ****************************************************************************/
4193 static uint32 dump_a_printer(NT_PRINTER_INFO_LEVEL *printer, uint32 level)
4196 NT_PRINTER_INFO_LEVEL_2 *info2;
4198 DEBUG(106,("Dumping printer at level [%d]\n", level));
4203 if (printer->info_2 == NULL)
4207 info2=printer->info_2;
4209 DEBUGADD(106,("attributes:[%d]\n", info2->attributes));
4210 DEBUGADD(106,("priority:[%d]\n", info2->priority));
4211 DEBUGADD(106,("default_priority:[%d]\n", info2->default_priority));
4212 DEBUGADD(106,("starttime:[%d]\n", info2->starttime));
4213 DEBUGADD(106,("untiltime:[%d]\n", info2->untiltime));
4214 DEBUGADD(106,("status:[%d]\n", info2->status));
4215 DEBUGADD(106,("cjobs:[%d]\n", info2->cjobs));
4216 DEBUGADD(106,("averageppm:[%d]\n", info2->averageppm));
4217 DEBUGADD(106,("changeid:[%d]\n", info2->changeid));
4218 DEBUGADD(106,("c_setprinter:[%d]\n", info2->c_setprinter));
4219 DEBUGADD(106,("setuptime:[%d]\n", info2->setuptime));
4221 DEBUGADD(106,("servername:[%s]\n", info2->servername));
4222 DEBUGADD(106,("printername:[%s]\n", info2->printername));
4223 DEBUGADD(106,("sharename:[%s]\n", info2->sharename));
4224 DEBUGADD(106,("portname:[%s]\n", info2->portname));
4225 DEBUGADD(106,("drivername:[%s]\n", info2->drivername));
4226 DEBUGADD(106,("comment:[%s]\n", info2->comment));
4227 DEBUGADD(106,("location:[%s]\n", info2->location));
4228 DEBUGADD(106,("sepfile:[%s]\n", info2->sepfile));
4229 DEBUGADD(106,("printprocessor:[%s]\n", info2->printprocessor));
4230 DEBUGADD(106,("datatype:[%s]\n", info2->datatype));
4231 DEBUGADD(106,("parameters:[%s]\n", info2->parameters));
4237 DEBUGADD(106,("dump_a_printer: Level %u not implemented\n", (unsigned int)level ));
4245 /****************************************************************************
4246 Update the changeid time.
4247 This is SO NASTY as some drivers need this to change, others need it
4248 static. This value will change every second, and I must hope that this
4249 is enough..... DON'T CHANGE THIS CODE WITHOUT A TEST MATRIX THE SIZE OF
4251 ****************************************************************************/
4253 static uint32 rev_changeid(void)
4257 get_process_uptime(&tv);
4260 /* Return changeid as msec since spooler restart */
4261 return tv.tv_sec * 1000 + tv.tv_usec / 1000;
4264 * This setting seems to work well but is too untested
4265 * to replace the above calculation. Left in for experiementation
4266 * of the reader --jerry (Tue Mar 12 09:15:05 CST 2002)
4268 return tv.tv_sec * 10 + tv.tv_usec / 100000;
4274 * The function below are the high level ones.
4275 * only those ones must be called from the spoolss code.
4279 /****************************************************************************
4280 Modify a printer. This is called from SETPRINTERDATA/DELETEPRINTERDATA.
4281 ****************************************************************************/
4283 WERROR mod_a_printer(NT_PRINTER_INFO_LEVEL *printer, uint32 level)
4287 dump_a_printer(printer, level);
4293 * Update the changestamp. Emperical tests show that the
4294 * ChangeID is always updated,but c_setprinter is
4295 * global spooler variable (not per printer).
4298 /* ChangeID **must** be increasing over the lifetime
4299 of client's spoolss service in order for the
4300 client's cache to show updates */
4302 printer->info_2->changeid = rev_changeid();
4305 * Because one day someone will ask:
4306 * NT->NT An admin connection to a remote
4307 * printer show changes imeediately in
4308 * the properities dialog
4310 * A non-admin connection will only show the
4311 * changes after viewing the properites page
4312 * 2 times. Seems to be related to a
4313 * race condition in the client between the spooler
4314 * updating the local cache and the Explorer.exe GUI
4315 * actually displaying the properties.
4317 * This is fixed in Win2k. admin/non-admin
4318 * connections both display changes immediately.
4323 result=update_a_printer_2(printer->info_2);
4327 result=WERR_UNKNOWN_LEVEL;
4334 /****************************************************************************
4335 Initialize printer devmode & data with previously saved driver init values.
4336 ****************************************************************************/
4338 static bool set_driver_init_2( NT_PRINTER_INFO_LEVEL_2 *info_ptr )
4343 NT_PRINTER_INFO_LEVEL_2 info;
4349 * Delete any printer data 'values' already set. When called for driver
4350 * replace, there will generally be some, but during an add printer, there
4351 * should not be any (if there are delete them).
4354 if ( info_ptr->data )
4355 delete_all_printer_data( info_ptr, "" );
4357 if (asprintf(&key, "%s%s", DRIVER_INIT_PREFIX,
4358 info_ptr->drivername) < 0) {
4362 dbuf = tdb_fetch_bystring(tdb_drivers, key);
4365 * When changing to a driver that has no init info in the tdb, remove
4366 * the previous drivers init info and leave the new on blank.
4368 free_nt_devicemode(&info_ptr->devmode);
4375 * Get the saved DEVMODE..
4378 len += unpack_devicemode(&info.devmode,dbuf.dptr+len, dbuf.dsize-len);
4381 * The saved DEVMODE contains the devicename from the printer used during
4382 * the initialization save. Change it to reflect the new printer.
4385 if ( info.devmode ) {
4386 ZERO_STRUCT(info.devmode->devicename);
4387 fstrcpy(info.devmode->devicename, info_ptr->printername);
4391 * NT/2k does not change out the entire DeviceMode of a printer
4392 * when changing the driver. Only the driverextra, private, &
4393 * driverversion fields. --jerry (Thu Mar 14 08:58:43 CST 2002)
4395 * Later examination revealed that Windows NT/2k does reset the
4396 * the printer's device mode, bit **only** when you change a
4397 * property of the device mode such as the page orientation.
4402 /* Bind the saved DEVMODE to the new the printer */
4404 free_nt_devicemode(&info_ptr->devmode);
4405 info_ptr->devmode = info.devmode;
4407 DEBUG(10,("set_driver_init_2: Set printer [%s] init %s DEVMODE for driver [%s]\n",
4408 info_ptr->printername, info_ptr->devmode?"VALID":"NULL", info_ptr->drivername));
4410 /* Add the printer data 'values' to the new printer */
4412 if ( !(info_ptr->data = TALLOC_ZERO_P( info_ptr, NT_PRINTER_DATA )) ) {
4413 DEBUG(0,("set_driver_init_2: talloc() failed!\n"));
4417 len += unpack_values( info_ptr->data, dbuf.dptr+len, dbuf.dsize-len );
4419 SAFE_FREE(dbuf.dptr);
4424 /****************************************************************************
4425 Initialize printer devmode & data with previously saved driver init values.
4426 When a printer is created using AddPrinter, the drivername bound to the
4427 printer is used to lookup previously saved driver initialization info, which
4428 is bound to the new printer.
4429 ****************************************************************************/
4431 bool set_driver_init(NT_PRINTER_INFO_LEVEL *printer, uint32 level)
4433 bool result = False;
4437 result = set_driver_init_2(printer->info_2);
4441 DEBUG(0,("set_driver_init: Programmer's error! Unknown driver_init level [%d]\n",
4449 /****************************************************************************
4450 Delete driver init data stored for a specified driver
4451 ****************************************************************************/
4453 bool del_driver_init(const char *drivername)
4458 if (!drivername || !*drivername) {
4459 DEBUG(3,("del_driver_init: No drivername specified!\n"));
4463 if (asprintf(&key, "%s%s", DRIVER_INIT_PREFIX, drivername) < 0) {
4467 DEBUG(6,("del_driver_init: Removing driver init data for [%s]\n",
4470 ret = (tdb_delete_bystring(tdb_drivers, key) == 0);
4475 /****************************************************************************
4476 Pack up the DEVMODE and values for a printer into a 'driver init' entry
4477 in the tdb. Note: this is different from the driver entry and the printer
4478 entry. There should be a single driver init entry for each driver regardless
4479 of whether it was installed from NT or 2K. Technically, they should be
4480 different, but they work out to the same struct.
4481 ****************************************************************************/
4483 static uint32 update_driver_init_2(NT_PRINTER_INFO_LEVEL_2 *info)
4487 int buflen, len, ret;
4496 len += pack_devicemode(info->devmode, buf+len, buflen-len);
4498 retlen = pack_values( info->data, buf+len, buflen-len );
4506 buf = (uint8 *)SMB_REALLOC(buf, len);
4508 DEBUG(0, ("update_driver_init_2: failed to enlarge buffer!\n"));
4517 if (asprintf(&key, "%s%s", DRIVER_INIT_PREFIX, info->drivername) < 0) {
4525 ret = tdb_store_bystring(tdb_drivers, key, dbuf, TDB_REPLACE);
4529 DEBUG(8, ("update_driver_init_2: error updating printer init to tdb on disk\n"));
4533 DEBUG(10,("update_driver_init_2: Saved printer [%s] init DEVMODE & values for driver [%s]\n",
4534 info->sharename, info->drivername));
4539 /****************************************************************************
4540 Update (i.e. save) the driver init info (DEVMODE and values) for a printer
4541 ****************************************************************************/
4543 static uint32 update_driver_init(NT_PRINTER_INFO_LEVEL *printer, uint32 level)
4547 dump_a_printer(printer, level);
4551 result = update_driver_init_2(printer->info_2);
4561 /****************************************************************************
4562 Convert the printer data value, a REG_BINARY array, into an initialization
4563 DEVMODE. Note: the array must be parsed as if it was a DEVMODE in an rpc...
4564 got to keep the endians happy :).
4565 ****************************************************************************/
4567 static bool convert_driver_init(TALLOC_CTX *mem_ctx, NT_DEVICEMODE *nt_devmode,
4568 const uint8_t *data, uint32_t data_len)
4570 struct spoolss_DeviceMode devmode;
4571 enum ndr_err_code ndr_err;
4574 ZERO_STRUCT(devmode);
4576 blob = data_blob_const(data, data_len);
4578 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, NULL, &devmode,
4579 (ndr_pull_flags_fn_t)ndr_pull_spoolss_DeviceMode);
4580 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4581 DEBUG(10,("convert_driver_init: error parsing spoolss_DeviceMode\n"));
4585 return convert_devicemode("", &devmode, &nt_devmode);
4588 /****************************************************************************
4589 Set the DRIVER_INIT info in the tdb. Requires Win32 client code that:
4591 1. Use the driver's config DLL to this UNC printername and:
4592 a. Call DrvPrintEvent with PRINTER_EVENT_INITIALIZE
4593 b. Call DrvConvertDevMode with CDM_DRIVER_DEFAULT to get default DEVMODE
4594 2. Call SetPrinterData with the 'magic' key and the DEVMODE as data.
4596 The last step triggers saving the "driver initialization" information for
4597 this printer into the tdb. Later, new printers that use this driver will
4598 have this initialization information bound to them. This simulates the
4599 driver initialization, as if it had run on the Samba server (as it would
4602 The Win32 client side code requirement sucks! But until we can run arbitrary
4603 Win32 printer driver code on any Unix that Samba runs on, we are stuck with it.
4605 It would have been easier to use SetPrinter because all the UNMARSHALLING of
4606 the DEVMODE is done there, but 2K/XP clients do not set the DEVMODE... think
4607 about it and you will realize why. JRR 010720
4608 ****************************************************************************/
4610 static WERROR save_driver_init_2(NT_PRINTER_INFO_LEVEL *printer, uint8 *data, uint32 data_len )
4612 WERROR status = WERR_OK;
4613 TALLOC_CTX *ctx = NULL;
4614 NT_DEVICEMODE *nt_devmode = NULL;
4615 NT_DEVICEMODE *tmp_devmode = printer->info_2->devmode;
4618 * When the DEVMODE is already set on the printer, don't try to unpack it.
4620 DEBUG(8,("save_driver_init_2: Enter...\n"));
4622 if ( !printer->info_2->devmode && data_len ) {
4624 * Set devmode on printer info, so entire printer initialization can be
4628 if ((ctx = talloc_init("save_driver_init_2")) == NULL)
4631 if ((nt_devmode = SMB_MALLOC_P(NT_DEVICEMODE)) == NULL) {
4632 status = WERR_NOMEM;
4636 ZERO_STRUCTP(nt_devmode);
4639 * The DEVMODE is held in the 'data' component of the param in raw binary.
4640 * Convert it to to a devmode structure
4642 if ( !convert_driver_init( ctx, nt_devmode, data, data_len )) {
4643 DEBUG(10,("save_driver_init_2: error converting DEVMODE\n"));
4644 status = WERR_INVALID_PARAM;
4648 printer->info_2->devmode = nt_devmode;
4652 * Pack up and add (or update) the DEVMODE and any current printer data to
4653 * a 'driver init' element in the tdb
4657 if ( update_driver_init(printer, 2) != 0 ) {
4658 DEBUG(10,("save_driver_init_2: error updating DEVMODE\n"));
4659 status = WERR_NOMEM;
4664 * If driver initialization info was successfully saved, set the current
4665 * printer to match it. This allows initialization of the current printer
4666 * as well as the driver.
4668 status = mod_a_printer(printer, 2);
4669 if (!W_ERROR_IS_OK(status)) {
4670 DEBUG(10,("save_driver_init_2: error setting DEVMODE on printer [%s]\n",
4671 printer->info_2->printername));
4675 talloc_destroy(ctx);
4676 free_nt_devicemode( &nt_devmode );
4678 printer->info_2->devmode = tmp_devmode;
4683 /****************************************************************************
4684 Update the driver init info (DEVMODE and specifics) for a printer
4685 ****************************************************************************/
4687 WERROR save_driver_init(NT_PRINTER_INFO_LEVEL *printer, uint32 level, uint8 *data, uint32 data_len)
4689 WERROR status = WERR_OK;
4693 status = save_driver_init_2( printer, data, data_len );
4696 status = WERR_UNKNOWN_LEVEL;
4703 /****************************************************************************
4704 Get a NT_PRINTER_INFO_LEVEL struct. It returns malloced memory.
4706 Previously the code had a memory allocation problem because it always
4707 used the TALLOC_CTX from the Printer_entry*. This context lasts
4708 as a long as the original handle is open. So if the client made a lot
4709 of getprinter[data]() calls, the memory usage would climb. Now we use
4710 a short lived TALLOC_CTX for printer_info_2 objects returned. We
4711 still use the Printer_entry->ctx for maintaining the cache copy though
4712 since that object must live as long as the handle by definition.
4715 ****************************************************************************/
4717 static WERROR get_a_printer_internal( Printer_entry *print_hnd, NT_PRINTER_INFO_LEVEL **pp_printer, uint32 level,
4718 const char *sharename, bool get_loc_com)
4723 DEBUG(10,("get_a_printer: [%s] level %u\n", sharename, (unsigned int)level));
4725 if ( !(*pp_printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
4726 DEBUG(0,("get_a_printer: talloc() fail.\n"));
4732 if ( !((*pp_printer)->info_2 = TALLOC_ZERO_P(*pp_printer, NT_PRINTER_INFO_LEVEL_2)) ) {
4733 DEBUG(0,("get_a_printer: talloc() fail.\n"));
4734 TALLOC_FREE( *pp_printer );
4739 fstrcpy( servername, print_hnd->servername );
4741 fstrcpy( servername, "%L" );
4742 standard_sub_basic( "", "", servername,
4743 sizeof(servername)-1 );
4746 result = get_a_printer_2( (*pp_printer)->info_2,
4747 servername, sharename, get_loc_com);
4749 /* we have a new printer now. Save it with this handle */
4751 if ( !W_ERROR_IS_OK(result) ) {
4752 TALLOC_FREE( *pp_printer );
4753 DEBUG(10,("get_a_printer: [%s] level %u returning %s\n",
4754 sharename, (unsigned int)level, win_errstr(result)));
4758 dump_a_printer( *pp_printer, level);
4763 TALLOC_FREE( *pp_printer );
4764 return WERR_UNKNOWN_LEVEL;
4770 WERROR get_a_printer( Printer_entry *print_hnd,
4771 NT_PRINTER_INFO_LEVEL **pp_printer,
4773 const char *sharename)
4775 return get_a_printer_internal(print_hnd, pp_printer, level,
4779 WERROR get_a_printer_search( Printer_entry *print_hnd,
4780 NT_PRINTER_INFO_LEVEL **pp_printer,
4782 const char *sharename)
4784 return get_a_printer_internal(print_hnd, pp_printer, level,
4788 /****************************************************************************
4789 Deletes a NT_PRINTER_INFO_LEVEL struct.
4790 ****************************************************************************/
4792 uint32 free_a_printer(NT_PRINTER_INFO_LEVEL **pp_printer, uint32 level)
4794 NT_PRINTER_INFO_LEVEL *printer = *pp_printer;
4801 if ( printer->info_2 )
4802 free_nt_printer_info_level_2(&printer->info_2);
4806 DEBUG(0,("free_a_printer: unknown level! [%d]\n", level ));
4810 TALLOC_FREE(*pp_printer);
4815 /****************************************************************************
4816 ****************************************************************************/
4817 uint32 add_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
4820 DEBUG(104,("adding a printer at level [%d]\n", level));
4821 dump_a_printer_driver(driver, level);
4825 result=add_a_printer_driver_3(driver.info_3);
4829 result=add_a_printer_driver_6(driver.info_6);
4839 /****************************************************************************
4840 ****************************************************************************/
4842 WERROR get_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL *driver, uint32_t level,
4843 const char *drivername, const char *architecture,
4850 /* Sometime we just want any version of the driver */
4852 if ( version == DRIVER_ANY_VERSION ) {
4853 /* look for Win2k first and then for NT4 */
4854 result = get_a_printer_driver_3(&driver->info_3, drivername,
4857 if ( !W_ERROR_IS_OK(result) ) {
4858 result = get_a_printer_driver_3( &driver->info_3,
4859 drivername, architecture, 2 );
4862 result = get_a_printer_driver_3(&driver->info_3, drivername,
4863 architecture, version);
4872 if (W_ERROR_IS_OK(result))
4873 dump_a_printer_driver(*driver, level);
4878 /****************************************************************************
4879 ****************************************************************************/
4880 uint32 free_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
4887 NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3;
4888 if (driver.info_3 != NULL)
4890 info3=driver.info_3;
4891 SAFE_FREE(info3->dependentfiles);
4892 ZERO_STRUCTP(info3);
4902 NT_PRINTER_DRIVER_INFO_LEVEL_6 *info6;
4903 if (driver.info_6 != NULL) {
4904 info6=driver.info_6;
4905 SAFE_FREE(info6->dependentfiles);
4906 SAFE_FREE(info6->previousnames);
4907 ZERO_STRUCTP(info6);
4923 /****************************************************************************
4924 Determine whether or not a particular driver is currently assigned
4926 ****************************************************************************/
4928 bool printer_driver_in_use ( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info_3 )
4931 int n_services = lp_numservices();
4932 NT_PRINTER_INFO_LEVEL *printer = NULL;
4933 bool in_use = False;
4938 DEBUG(10,("printer_driver_in_use: Beginning search through ntprinters.tdb...\n"));
4940 /* loop through the printers.tdb and check for the drivername */
4942 for (snum=0; snum<n_services && !in_use; snum++) {
4943 if ( !(lp_snum_ok(snum) && lp_print_ok(snum) ) )
4946 if ( !W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_servicename(snum))) )
4949 if ( strequal(info_3->name, printer->info_2->drivername) )
4952 free_a_printer( &printer, 2 );
4955 DEBUG(10,("printer_driver_in_use: Completed search through ntprinters.tdb...\n"));
4958 NT_PRINTER_DRIVER_INFO_LEVEL d;
4961 DEBUG(5,("printer_driver_in_use: driver \"%s\" is currently in use\n", info_3->name));
4963 /* we can still remove the driver if there is one of
4964 "Windows NT x86" version 2 or 3 left */
4966 if ( !strequal( "Windows NT x86", info_3->environment ) ) {
4967 werr = get_a_printer_driver( &d, 3, info_3->name, "Windows NT x86", DRIVER_ANY_VERSION );
4970 switch ( info_3->cversion ) {
4972 werr = get_a_printer_driver( &d, 3, info_3->name, "Windows NT x86", 3 );
4975 werr = get_a_printer_driver( &d, 3, info_3->name, "Windows NT x86", 2 );
4978 DEBUG(0,("printer_driver_in_use: ERROR! unknown driver version (%d)\n",
4980 werr = WERR_UNKNOWN_PRINTER_DRIVER;
4985 /* now check the error code */
4987 if ( W_ERROR_IS_OK(werr) ) {
4988 /* it's ok to remove the driver, we have other architctures left */
4990 free_a_printer_driver( d, 3 );
4994 /* report that the driver is not in use by default */
5000 /**********************************************************************
5001 Check to see if a ogiven file is in use by *info
5002 *********************************************************************/
5004 static bool drv_file_in_use( char* file, NT_PRINTER_DRIVER_INFO_LEVEL_3 *info )
5011 /* mz: skip files that are in the list but already deleted */
5012 if (!file || !file[0]) {
5016 if ( strequal(file, info->driverpath) )
5019 if ( strequal(file, info->datafile) )
5022 if ( strequal(file, info->configfile) )
5025 if ( strequal(file, info->helpfile) )
5028 /* see of there are any dependent files to examine */
5030 if ( !info->dependentfiles )
5033 while ( *info->dependentfiles[i] ) {
5034 if ( strequal(file, info->dependentfiles[i]) )
5043 /**********************************************************************
5044 Utility function to remove the dependent file pointed to by the
5045 input parameter from the list
5046 *********************************************************************/
5048 static void trim_dependent_file( fstring files[], int idx )
5051 /* bump everything down a slot */
5053 while( *files[idx+1] ) {
5054 fstrcpy( files[idx], files[idx+1] );
5063 /**********************************************************************
5064 Check if any of the files used by src are also used by drv
5065 *********************************************************************/
5067 static bool trim_overlap_drv_files( NT_PRINTER_DRIVER_INFO_LEVEL_3 *src,
5068 NT_PRINTER_DRIVER_INFO_LEVEL_3 *drv )
5070 bool in_use = False;
5076 /* check each file. Remove it from the src structure if it overlaps */
5078 if ( drv_file_in_use(src->driverpath, drv) ) {
5080 DEBUG(10,("Removing driverfile [%s] from list\n", src->driverpath));
5081 fstrcpy( src->driverpath, "" );
5084 if ( drv_file_in_use(src->datafile, drv) ) {
5086 DEBUG(10,("Removing datafile [%s] from list\n", src->datafile));
5087 fstrcpy( src->datafile, "" );
5090 if ( drv_file_in_use(src->configfile, drv) ) {
5092 DEBUG(10,("Removing configfile [%s] from list\n", src->configfile));
5093 fstrcpy( src->configfile, "" );
5096 if ( drv_file_in_use(src->helpfile, drv) ) {
5098 DEBUG(10,("Removing helpfile [%s] from list\n", src->helpfile));
5099 fstrcpy( src->helpfile, "" );
5102 /* are there any dependentfiles to examine? */
5104 if ( !src->dependentfiles )
5107 while ( *src->dependentfiles[i] ) {
5108 if ( drv_file_in_use(src->dependentfiles[i], drv) ) {
5110 DEBUG(10,("Removing [%s] from dependent file list\n", src->dependentfiles[i]));
5111 trim_dependent_file( src->dependentfiles, i );
5119 /****************************************************************************
5120 Determine whether or not a particular driver files are currently being
5121 used by any other driver.
5123 Return value is True if any files were in use by other drivers
5124 and False otherwise.
5126 Upon return, *info has been modified to only contain the driver files
5127 which are not in use
5131 This needs to check all drivers to ensure that all files in use
5132 have been removed from *info, not just the ones in the first
5134 ****************************************************************************/
5136 bool printer_driver_files_in_use ( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info )
5141 fstring *list = NULL;
5142 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5143 bool in_use = false;
5148 version = info->cversion;
5150 /* loop over all driver versions */
5152 DEBUG(5,("printer_driver_files_in_use: Beginning search through ntdrivers.tdb...\n"));
5154 /* get the list of drivers */
5157 ndrivers = get_ntdrivers(&list, info->environment, version);
5159 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
5160 ndrivers, info->environment, version));
5162 /* check each driver for overlap in files */
5164 for (i=0; i<ndrivers; i++) {
5165 DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
5167 ZERO_STRUCT(driver);
5169 if ( !W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, list[i], info->environment, version)) ) {
5174 /* check if d2 uses any files from d1 */
5175 /* only if this is a different driver than the one being deleted */
5177 if ( !strequal(info->name, driver.info_3->name) ) {
5178 if ( trim_overlap_drv_files(info, driver.info_3) ) {
5179 /* mz: Do not instantly return -
5180 * we need to ensure this file isn't
5181 * also in use by other drivers. */
5186 free_a_printer_driver(driver, 3);
5191 DEBUG(5,("printer_driver_files_in_use: Completed search through ntdrivers.tdb...\n"));
5193 driver.info_3 = info;
5195 if ( DEBUGLEVEL >= 20 )
5196 dump_a_printer_driver( driver, 3 );
5201 /****************************************************************************
5202 Actually delete the driver files. Make sure that
5203 printer_driver_files_in_use() return False before calling
5205 ****************************************************************************/
5207 static bool delete_driver_files(struct pipes_struct *rpc_pipe,
5208 NT_PRINTER_DRIVER_INFO_LEVEL_3 *info_3)
5213 connection_struct *conn;
5217 fstring printdollar;
5218 int printdollar_snum;
5224 DEBUG(6,("delete_driver_files: deleting driver [%s] - version [%d]\n", info_3->name, info_3->cversion));
5226 fstrcpy(printdollar, "print$");
5228 printdollar_snum = find_service(printdollar);
5229 if (printdollar_snum == -1) {
5233 nt_status = create_conn_struct(talloc_tos(), &conn, printdollar_snum,
5234 lp_pathname(printdollar_snum),
5235 rpc_pipe->server_info, &oldcwd);
5236 if (!NT_STATUS_IS_OK(nt_status)) {
5237 DEBUG(0,("delete_driver_files: create_conn_struct "
5238 "returned %s\n", nt_errstr(nt_status)));
5242 if ( !CAN_WRITE(conn) ) {
5243 DEBUG(3,("delete_driver_files: Cannot delete print driver when [print$] is read-only\n"));
5247 /* now delete the files; must strip the '\print$' string from
5250 if ( *info_3->driverpath ) {
5251 if ( (s = strchr( &info_3->driverpath[1], '\\' )) != NULL ) {
5253 driver_unix_convert(conn,file,&st);
5254 DEBUG(10,("deleting driverfile [%s]\n", s));
5255 unlink_internals(conn, NULL, 0, file, False);
5259 if ( *info_3->configfile ) {
5260 if ( (s = strchr( &info_3->configfile[1], '\\' )) != NULL ) {
5262 driver_unix_convert(conn,file,&st);
5263 DEBUG(10,("deleting configfile [%s]\n", s));
5264 unlink_internals(conn, NULL, 0, file, False);
5268 if ( *info_3->datafile ) {
5269 if ( (s = strchr( &info_3->datafile[1], '\\' )) != NULL ) {
5271 driver_unix_convert(conn,file,&st);
5272 DEBUG(10,("deleting datafile [%s]\n", s));
5273 unlink_internals(conn, NULL, 0, file, False);
5277 if ( *info_3->helpfile ) {
5278 if ( (s = strchr( &info_3->helpfile[1], '\\' )) != NULL ) {
5280 driver_unix_convert(conn,file,&st);
5281 DEBUG(10,("deleting helpfile [%s]\n", s));
5282 unlink_internals(conn, NULL, 0, file, False);
5286 /* check if we are done removing files */
5288 if ( info_3->dependentfiles ) {
5289 while ( info_3->dependentfiles[i][0] ) {
5292 /* bypass the "\print$" portion of the path */
5294 if ( (p = strchr( info_3->dependentfiles[i]+1, '\\' )) != NULL ) {
5296 driver_unix_convert(conn,file,&st);
5297 DEBUG(10,("deleting dependent file [%s]\n", file));
5298 unlink_internals(conn, NULL, 0, file, False);
5310 vfs_ChDir(conn, oldcwd);
5311 conn_free_internal(conn);
5316 /****************************************************************************
5317 Remove a printer driver from the TDB. This assumes that the the driver was
5318 previously looked up.
5319 ***************************************************************************/
5321 WERROR delete_printer_driver(struct pipes_struct *rpc_pipe,
5322 NT_PRINTER_DRIVER_INFO_LEVEL_3 *info_3,
5323 uint32 version, bool delete_files )
5328 NT_PRINTER_DRIVER_INFO_LEVEL ctr;
5330 /* delete the tdb data first */
5332 arch = get_short_archi(info_3->environment);
5334 return WERR_UNKNOWN_PRINTER_DRIVER;
5336 if (asprintf(&key, "%s%s/%d/%s", DRIVERS_PREFIX,
5337 arch, version, info_3->name) < 0) {
5341 DEBUG(5,("delete_printer_driver: key = [%s] delete_files = %s\n",
5342 key, delete_files ? "TRUE" : "FALSE" ));
5344 ctr.info_3 = info_3;
5345 dump_a_printer_driver( ctr, 3 );
5347 /* check if the driver actually exists for this environment */
5349 dbuf = tdb_fetch_bystring( tdb_drivers, key );
5351 DEBUG(8,("delete_printer_driver: Driver unknown [%s]\n", key));
5353 return WERR_UNKNOWN_PRINTER_DRIVER;
5356 SAFE_FREE( dbuf.dptr );
5358 /* ok... the driver exists so the delete should return success */
5360 if (tdb_delete_bystring(tdb_drivers, key) == -1) {
5361 DEBUG (0,("delete_printer_driver: fail to delete %s!\n", key));
5363 return WERR_ACCESS_DENIED;
5367 * now delete any associated files if delete_files == True
5368 * even if this part failes, we return succes because the
5369 * driver doesn not exist any more
5373 delete_driver_files(rpc_pipe, info_3);
5375 DEBUG(5,("delete_printer_driver: driver delete successful [%s]\n", key));
5381 /****************************************************************************
5382 Store a security desc for a printer.
5383 ****************************************************************************/
5385 WERROR nt_printing_setsec(const char *sharename, SEC_DESC_BUF *secdesc_ctr)
5387 SEC_DESC_BUF *new_secdesc_ctr = NULL;
5388 SEC_DESC_BUF *old_secdesc_ctr = NULL;
5389 TALLOC_CTX *mem_ctx = NULL;
5396 mem_ctx = talloc_init("nt_printing_setsec");
5397 if (mem_ctx == NULL)
5400 /* The old owner and group sids of the security descriptor are not
5401 present when new ACEs are added or removed by changing printer
5402 permissions through NT. If they are NULL in the new security
5403 descriptor then copy them over from the old one. */
5405 if (!secdesc_ctr->sd->owner_sid || !secdesc_ctr->sd->group_sid) {
5406 DOM_SID *owner_sid, *group_sid;
5407 SEC_ACL *dacl, *sacl;
5408 SEC_DESC *psd = NULL;
5411 if (!nt_printing_getsec(mem_ctx, sharename, &old_secdesc_ctr)) {
5412 status = WERR_NOMEM;
5416 /* Pick out correct owner and group sids */
5418 owner_sid = secdesc_ctr->sd->owner_sid ?
5419 secdesc_ctr->sd->owner_sid :
5420 old_secdesc_ctr->sd->owner_sid;
5422 group_sid = secdesc_ctr->sd->group_sid ?
5423 secdesc_ctr->sd->group_sid :
5424 old_secdesc_ctr->sd->group_sid;
5426 dacl = secdesc_ctr->sd->dacl ?
5427 secdesc_ctr->sd->dacl :
5428 old_secdesc_ctr->sd->dacl;
5430 sacl = secdesc_ctr->sd->sacl ?
5431 secdesc_ctr->sd->sacl :
5432 old_secdesc_ctr->sd->sacl;
5434 /* Make a deep copy of the security descriptor */
5436 psd = make_sec_desc(mem_ctx, secdesc_ctr->sd->revision, secdesc_ctr->sd->type,
5437 owner_sid, group_sid,
5443 status = WERR_NOMEM;
5447 new_secdesc_ctr = make_sec_desc_buf(mem_ctx, size, psd);
5450 if (!new_secdesc_ctr) {
5451 new_secdesc_ctr = secdesc_ctr;
5454 /* Store the security descriptor in a tdb */
5456 nt_status = marshall_sec_desc_buf(mem_ctx, new_secdesc_ctr,
5457 &blob.data, &blob.length);
5458 if (!NT_STATUS_IS_OK(nt_status)) {
5459 status = ntstatus_to_werror(nt_status);
5463 kbuf = make_printers_secdesc_tdbkey(mem_ctx, sharename );
5465 dbuf.dptr = (unsigned char *)blob.data;
5466 dbuf.dsize = blob.length;
5468 if (tdb_trans_store(tdb_printers, kbuf, dbuf, TDB_REPLACE)==0) {
5471 DEBUG(1,("Failed to store secdesc for %s\n", sharename));
5472 status = WERR_BADFUNC;
5475 /* Free malloc'ed memory */
5476 talloc_free(blob.data);
5481 talloc_destroy(mem_ctx);
5485 /****************************************************************************
5486 Construct a default security descriptor buffer for a printer.
5487 ****************************************************************************/
5489 static SEC_DESC_BUF *construct_default_printer_sdb(TALLOC_CTX *ctx)
5491 SEC_ACE ace[5]; /* max number of ace entries */
5494 SEC_ACL *psa = NULL;
5495 SEC_DESC_BUF *sdb = NULL;
5496 SEC_DESC *psd = NULL;
5500 /* Create an ACE where Everyone is allowed to print */
5502 sa = PRINTER_ACE_PRINT;
5503 init_sec_ace(&ace[i++], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED,
5504 sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
5506 /* Add the domain admins group if we are a DC */
5509 DOM_SID domadmins_sid;
5511 sid_copy(&domadmins_sid, get_global_sam_sid());
5512 sid_append_rid(&domadmins_sid, DOMAIN_GROUP_RID_ADMINS);
5514 sa = PRINTER_ACE_FULL_CONTROL;
5515 init_sec_ace(&ace[i++], &domadmins_sid,
5516 SEC_ACE_TYPE_ACCESS_ALLOWED, sa,
5517 SEC_ACE_FLAG_OBJECT_INHERIT | SEC_ACE_FLAG_INHERIT_ONLY);
5518 init_sec_ace(&ace[i++], &domadmins_sid, SEC_ACE_TYPE_ACCESS_ALLOWED,
5519 sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
5521 else if (secrets_fetch_domain_sid(lp_workgroup(), &adm_sid)) {
5522 sid_append_rid(&adm_sid, DOMAIN_USER_RID_ADMIN);
5524 sa = PRINTER_ACE_FULL_CONTROL;
5525 init_sec_ace(&ace[i++], &adm_sid,
5526 SEC_ACE_TYPE_ACCESS_ALLOWED, sa,
5527 SEC_ACE_FLAG_OBJECT_INHERIT | SEC_ACE_FLAG_INHERIT_ONLY);
5528 init_sec_ace(&ace[i++], &adm_sid, SEC_ACE_TYPE_ACCESS_ALLOWED,
5529 sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
5532 /* add BUILTIN\Administrators as FULL CONTROL */
5534 sa = PRINTER_ACE_FULL_CONTROL;
5535 init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators,
5536 SEC_ACE_TYPE_ACCESS_ALLOWED, sa,
5537 SEC_ACE_FLAG_OBJECT_INHERIT | SEC_ACE_FLAG_INHERIT_ONLY);
5538 init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators,
5539 SEC_ACE_TYPE_ACCESS_ALLOWED,
5540 sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
5542 /* Make the security descriptor owned by the BUILTIN\Administrators */
5544 /* The ACL revision number in rpc_secdesc.h differs from the one
5545 created by NT when setting ACE entries in printer
5546 descriptors. NT4 complains about the property being edited by a
5549 if ((psa = make_sec_acl(ctx, NT4_ACL_REVISION, i, ace)) != NULL) {
5550 psd = make_sec_desc(ctx, SEC_DESC_REVISION, SEC_DESC_SELF_RELATIVE,
5551 &global_sid_Builtin_Administrators,
5552 &global_sid_Builtin_Administrators,
5553 NULL, psa, &sd_size);
5557 DEBUG(0,("construct_default_printer_sd: Failed to make SEC_DESC.\n"));
5561 sdb = make_sec_desc_buf(ctx, sd_size, psd);
5563 DEBUG(4,("construct_default_printer_sdb: size = %u.\n",
5564 (unsigned int)sd_size));
5569 /****************************************************************************
5570 Get a security desc for a printer.
5571 ****************************************************************************/
5573 bool nt_printing_getsec(TALLOC_CTX *ctx, const char *sharename, SEC_DESC_BUF **secdesc_ctr)
5581 if (strlen(sharename) > 2 && (temp = strchr(sharename + 2, '\\'))) {
5582 sharename = temp + 1;
5585 /* Fetch security descriptor from tdb */
5587 kbuf = make_printers_secdesc_tdbkey(ctx, sharename);
5589 dbuf = tdb_fetch(tdb_printers, kbuf);
5592 status = unmarshall_sec_desc_buf(ctx, dbuf.dptr, dbuf.dsize,
5594 SAFE_FREE(dbuf.dptr);
5596 if (NT_STATUS_IS_OK(status)) {
5601 *secdesc_ctr = construct_default_printer_sdb(ctx);
5602 if (!*secdesc_ctr) {
5606 status = marshall_sec_desc_buf(ctx, *secdesc_ctr,
5607 &blob.data, &blob.length);
5608 if (NT_STATUS_IS_OK(status)) {
5609 dbuf.dptr = (unsigned char *)blob.data;
5610 dbuf.dsize = blob.length;
5611 tdb_trans_store(tdb_printers, kbuf, dbuf, TDB_REPLACE);
5612 talloc_free(blob.data);
5615 /* If security descriptor is owned by S-1-1-0 and winbindd is up,
5616 this security descriptor has been created when winbindd was
5617 down. Take ownership of security descriptor. */
5619 if (sid_equal((*secdesc_ctr)->sd->owner_sid, &global_sid_World)) {
5622 /* Change sd owner to workgroup administrator */
5624 if (secrets_fetch_domain_sid(lp_workgroup(), &owner_sid)) {
5625 SEC_DESC_BUF *new_secdesc_ctr = NULL;
5626 SEC_DESC *psd = NULL;
5631 sid_append_rid(&owner_sid, DOMAIN_USER_RID_ADMIN);
5633 psd = make_sec_desc(ctx, (*secdesc_ctr)->sd->revision, (*secdesc_ctr)->sd->type,
5635 (*secdesc_ctr)->sd->group_sid,
5636 (*secdesc_ctr)->sd->sacl,
5637 (*secdesc_ctr)->sd->dacl,
5644 new_secdesc_ctr = make_sec_desc_buf(ctx, size, psd);
5645 if (!new_secdesc_ctr) {
5649 /* Swap with other one */
5651 *secdesc_ctr = new_secdesc_ctr;
5655 nt_printing_setsec(sharename, *secdesc_ctr);
5659 if (DEBUGLEVEL >= 10) {
5660 SEC_ACL *the_acl = (*secdesc_ctr)->sd->dacl;
5663 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5664 sharename, the_acl->num_aces));
5666 for (i = 0; i < the_acl->num_aces; i++) {
5667 DEBUG(10, ("%s %d %d 0x%08x\n",
5668 sid_string_dbg(&the_acl->aces[i].trustee),
5669 the_acl->aces[i].type, the_acl->aces[i].flags,
5670 the_acl->aces[i].access_mask));
5679 1: level not implemented
5680 2: file doesn't exist
5681 3: can't allocate memory
5682 4: can't free memory
5683 5: non existant struct
5687 A printer and a printer driver are 2 different things.
5688 NT manages them separatelly, Samba does the same.
5689 Why ? Simply because it's easier and it makes sense !
5691 Now explanation: You have 3 printers behind your samba server,
5692 2 of them are the same make and model (laser A and B). But laser B
5693 has an 3000 sheet feeder and laser A doesn't such an option.
5694 Your third printer is an old dot-matrix model for the accounting :-).
5696 If the /usr/local/samba/lib directory (default dir), you will have
5697 5 files to describe all of this.
5699 3 files for the printers (1 by printer):
5702 NTprinter_accounting
5703 2 files for the drivers (1 for the laser and 1 for the dot matrix)
5704 NTdriver_printer model X
5705 NTdriver_printer model Y
5707 jfm: I should use this comment for the text file to explain
5708 same thing for the forms BTW.
5709 Je devrais mettre mes commentaires en francais, ca serait mieux :-)
5713 /* Convert generic access rights to printer object specific access rights.
5714 It turns out that NT4 security descriptors use generic access rights and
5715 NT5 the object specific ones. */
5717 void map_printer_permissions(SEC_DESC *sd)
5721 for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) {
5722 se_map_generic(&sd->dacl->aces[i].access_mask,
5723 &printer_generic_mapping);
5727 void map_job_permissions(SEC_DESC *sd)
5731 for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) {
5732 se_map_generic(&sd->dacl->aces[i].access_mask,
5733 &job_generic_mapping);
5738 /****************************************************************************
5739 Check a user has permissions to perform the given operation. We use the
5740 permission constants defined in include/rpc_spoolss.h to check the various
5741 actions we perform when checking printer access.
5743 PRINTER_ACCESS_ADMINISTER:
5744 print_queue_pause, print_queue_resume, update_printer_sec,
5745 update_printer, spoolss_addprinterex_level_2,
5746 _spoolss_setprinterdata
5751 JOB_ACCESS_ADMINISTER:
5752 print_job_delete, print_job_pause, print_job_resume,
5755 Try access control in the following order (for performance reasons):
5756 1) root ans SE_PRINT_OPERATOR can do anything (easy check)
5757 2) check security descriptor (bit comparisons in memory)
5758 3) "printer admins" (may result in numerous calls to winbind)
5760 ****************************************************************************/
5761 bool print_access_check(struct auth_serversupplied_info *server_info, int snum,
5764 SEC_DESC_BUF *secdesc = NULL;
5765 uint32 access_granted;
5768 TALLOC_CTX *mem_ctx = NULL;
5769 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5771 /* If user is NULL then use the current_user structure */
5773 /* Always allow root or SE_PRINT_OPERATROR to do anything */
5775 if (server_info->utok.uid == 0
5776 || user_has_privileges(server_info->ptok, &se_printop ) ) {
5780 /* Get printer name */
5782 pname = PRINTERNAME(snum);
5784 if (!pname || !*pname) {
5789 /* Get printer security descriptor */
5791 if(!(mem_ctx = talloc_init("print_access_check"))) {
5796 if (!nt_printing_getsec(mem_ctx, pname, &secdesc)) {
5797 talloc_destroy(mem_ctx);
5802 if (access_type == JOB_ACCESS_ADMINISTER) {
5803 SEC_DESC_BUF *parent_secdesc = secdesc;
5805 /* Create a child security descriptor to check permissions
5806 against. This is because print jobs are child objects
5807 objects of a printer. */
5809 status = se_create_child_secdesc_buf(mem_ctx, &secdesc, parent_secdesc->sd, False);
5811 if (!NT_STATUS_IS_OK(status)) {
5812 talloc_destroy(mem_ctx);
5813 errno = map_errno_from_nt_status(status);
5817 map_job_permissions(secdesc->sd);
5819 map_printer_permissions(secdesc->sd);
5823 status = se_access_check(secdesc->sd, server_info->ptok, access_type,
5826 DEBUG(4, ("access check was %s\n", NT_STATUS_IS_OK(status) ? "SUCCESS" : "FAILURE"));
5828 /* see if we need to try the printer admin list */
5830 if ((access_granted == 0) &&
5831 (token_contains_name_in_list(uidtoname(server_info->utok.uid),
5832 NULL, NULL, server_info->ptok,
5833 lp_printer_admin(snum)))) {
5834 talloc_destroy(mem_ctx);
5838 talloc_destroy(mem_ctx);
5840 if (!NT_STATUS_IS_OK(status)) {
5844 return NT_STATUS_IS_OK(status);
5847 /****************************************************************************
5848 Check the time parameters allow a print operation.
5849 *****************************************************************************/
5851 bool print_time_access_check(const char *servicename)
5853 NT_PRINTER_INFO_LEVEL *printer = NULL;
5855 time_t now = time(NULL);
5859 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
5862 if (printer->info_2->starttime == 0 && printer->info_2->untiltime == 0)
5866 mins = (uint32)t->tm_hour*60 + (uint32)t->tm_min;
5868 if (mins >= printer->info_2->starttime && mins <= printer->info_2->untiltime)
5871 free_a_printer(&printer, 2);
5879 /****************************************************************************
5880 Fill in the servername sent in the _spoolss_open_printer_ex() call
5881 ****************************************************************************/
5883 char* get_server_name( Printer_entry *printer )
5885 return printer->servername;