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 2 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, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 extern struct current_user current_user
;
27 static TDB_CONTEXT
*tdb_forms
; /* used for forms files */
28 static TDB_CONTEXT
*tdb_drivers
; /* used for driver files */
29 static TDB_CONTEXT
*tdb_printers
; /* used for printers files */
31 #define FORMS_PREFIX "FORMS/"
32 #define DRIVERS_PREFIX "DRIVERS/"
33 #define DRIVER_INIT_PREFIX "DRIVER_INIT/"
34 #define PRINTERS_PREFIX "PRINTERS/"
35 #define SECDESC_PREFIX "SECDESC/"
36 #define GLOBAL_C_SETPRINTER "GLOBALS/c_setprinter"
38 #define NTDRIVERS_DATABASE_VERSION_1 1
39 #define NTDRIVERS_DATABASE_VERSION_2 2
40 #define NTDRIVERS_DATABASE_VERSION_3 3 /* little endian version of v2 */
41 #define NTDRIVERS_DATABASE_VERSION_4 4 /* fix generic bits in security descriptors */
42 #define NTDRIVERS_DATABASE_VERSION_5 5 /* normalize keys in ntprinters.tdb */
44 /* Map generic permissions to printer object specific permissions */
46 GENERIC_MAPPING printer_generic_mapping
= {
53 STANDARD_MAPPING printer_std_mapping
= {
60 /* Map generic permissions to print server object specific permissions */
62 GENERIC_MAPPING printserver_generic_mapping
= {
69 STANDARD_MAPPING printserver_std_mapping
= {
76 /* We need one default form to support our default printer. Msoft adds the
77 forms it wants and in the ORDER it wants them (note: DEVMODE papersize is an
78 array index). Letter is always first, so (for the current code) additions
79 always put things in the correct order. */
80 static const nt_forms_struct default_forms
[] = {
81 {"Letter",0x1,0x34b5c,0x44368,0x0,0x0,0x34b5c,0x44368},
82 {"Letter Small",0x1,0x34b5c,0x44368,0x0,0x0,0x34b5c,0x44368},
83 {"Tabloid",0x1,0x44368,0x696b8,0x0,0x0,0x44368,0x696b8},
84 {"Ledger",0x1,0x696b8,0x44368,0x0,0x0,0x696b8,0x44368},
85 {"Legal",0x1,0x34b5c,0x56d10,0x0,0x0,0x34b5c,0x56d10},
86 {"Statement",0x1,0x221b4,0x34b5c,0x0,0x0,0x221b4,0x34b5c},
87 {"Executive",0x1,0x2cf56,0x411cc,0x0,0x0,0x2cf56,0x411cc},
88 {"A3",0x1,0x48828,0x668a0,0x0,0x0,0x48828,0x668a0},
89 {"A4",0x1,0x33450,0x48828,0x0,0x0,0x33450,0x48828},
90 {"A4 Small",0x1,0x33450,0x48828,0x0,0x0,0x33450,0x48828},
91 {"A5",0x1,0x24220,0x33450,0x0,0x0,0x24220,0x33450},
92 {"B4 (JIS)",0x1,0x3ebe8,0x58de0,0x0,0x0,0x3ebe8,0x58de0},
93 {"B5 (JIS)",0x1,0x2c6f0,0x3ebe8,0x0,0x0,0x2c6f0,0x3ebe8},
94 {"Folio",0x1,0x34b5c,0x509d8,0x0,0x0,0x34b5c,0x509d8},
95 {"Quarto",0x1,0x347d8,0x43238,0x0,0x0,0x347d8,0x43238},
96 {"10x14",0x1,0x3e030,0x56d10,0x0,0x0,0x3e030,0x56d10},
97 {"11x17",0x1,0x44368,0x696b8,0x0,0x0,0x44368,0x696b8},
98 {"Note",0x1,0x34b5c,0x44368,0x0,0x0,0x34b5c,0x44368},
99 {"Envelope #9",0x1,0x18079,0x37091,0x0,0x0,0x18079,0x37091},
100 {"Envelope #10",0x1,0x19947,0x3ae94,0x0,0x0,0x19947,0x3ae94},
101 {"Envelope #11",0x1,0x1be7c,0x40565,0x0,0x0,0x1be7c,0x40565},
102 {"Envelope #12",0x1,0x1d74a,0x44368,0x0,0x0,0x1d74a,0x44368},
103 {"Envelope #14",0x1,0x1f018,0x47504,0x0,0x0,0x1f018,0x47504},
104 {"C size sheet",0x1,0x696b8,0x886d0,0x0,0x0,0x696b8,0x886d0},
105 {"D size sheet",0x1,0x886d0,0xd2d70,0x0,0x0,0x886d0,0xd2d70},
106 {"E size sheet",0x1,0xd2d70,0x110da0,0x0,0x0,0xd2d70,0x110da0},
107 {"Envelope DL",0x1,0x1adb0,0x35b60,0x0,0x0,0x1adb0,0x35b60},
108 {"Envelope C5",0x1,0x278d0,0x37e88,0x0,0x0,0x278d0,0x37e88},
109 {"Envelope C3",0x1,0x4f1a0,0x6fd10,0x0,0x0,0x4f1a0,0x6fd10},
110 {"Envelope C4",0x1,0x37e88,0x4f1a0,0x0,0x0,0x37e88,0x4f1a0},
111 {"Envelope C6",0x1,0x1bd50,0x278d0,0x0,0x0,0x1bd50,0x278d0},
112 {"Envelope C65",0x1,0x1bd50,0x37e88,0x0,0x0,0x1bd50,0x37e88},
113 {"Envelope B4",0x1,0x3d090,0x562e8,0x0,0x0,0x3d090,0x562e8},
114 {"Envelope B5",0x1,0x2af80,0x3d090,0x0,0x0,0x2af80,0x3d090},
115 {"Envelope B6",0x1,0x2af80,0x1e848,0x0,0x0,0x2af80,0x1e848},
116 {"Envelope",0x1,0x1adb0,0x38270,0x0,0x0,0x1adb0,0x38270},
117 {"Envelope Monarch",0x1,0x18079,0x2e824,0x0,0x0,0x18079,0x2e824},
118 {"6 3/4 Envelope",0x1,0x167ab,0x284ec,0x0,0x0,0x167ab,0x284ec},
119 {"US Std Fanfold",0x1,0x5c3e1,0x44368,0x0,0x0,0x5c3e1,0x44368},
120 {"German Std Fanfold",0x1,0x34b5c,0x4a6a0,0x0,0x0,0x34b5c,0x4a6a0},
121 {"German Legal Fanfold",0x1,0x34b5c,0x509d8,0x0,0x0,0x34b5c,0x509d8},
122 {"B4 (ISO)",0x1,0x3d090,0x562e8,0x0,0x0,0x3d090,0x562e8},
123 {"Japanese Postcard",0x1,0x186a0,0x24220,0x0,0x0,0x186a0,0x24220},
124 {"9x11",0x1,0x37cf8,0x44368,0x0,0x0,0x37cf8,0x44368},
125 {"10x11",0x1,0x3e030,0x44368,0x0,0x0,0x3e030,0x44368},
126 {"15x11",0x1,0x5d048,0x44368,0x0,0x0,0x5d048,0x44368},
127 {"Envelope Invite",0x1,0x35b60,0x35b60,0x0,0x0,0x35b60,0x35b60},
128 {"Reserved48",0x1,0x1,0x1,0x0,0x0,0x1,0x1},
129 {"Reserved49",0x1,0x1,0x1,0x0,0x0,0x1,0x1},
130 {"Letter Extra",0x1,0x3ae94,0x4a6a0,0x0,0x0,0x3ae94,0x4a6a0},
131 {"Legal Extra",0x1,0x3ae94,0x5d048,0x0,0x0,0x3ae94,0x5d048},
132 {"Tabloid Extra",0x1,0x4a6a0,0x6f9f0,0x0,0x0,0x4a6a0,0x6f9f0},
133 {"A4 Extra",0x1,0x397c2,0x4eb16,0x0,0x0,0x397c2,0x4eb16},
134 {"Letter Transverse",0x1,0x34b5c,0x44368,0x0,0x0,0x34b5c,0x44368},
135 {"A4 Transverse",0x1,0x33450,0x48828,0x0,0x0,0x33450,0x48828},
136 {"Letter Extra Transverse",0x1,0x3ae94,0x4a6a0,0x0,0x0,0x3ae94,0x4a6a0},
137 {"Super A",0x1,0x376b8,0x56ea0,0x0,0x0,0x376b8,0x56ea0},
138 {"Super B",0x1,0x4a768,0x76e58,0x0,0x0,0x4a768,0x76e58},
139 {"Letter Plus",0x1,0x34b5c,0x4eb16,0x0,0x0,0x34b5c,0x4eb16},
140 {"A4 Plus",0x1,0x33450,0x50910,0x0,0x0,0x33450,0x50910},
141 {"A5 Transverse",0x1,0x24220,0x33450,0x0,0x0,0x24220,0x33450},
142 {"B5 (JIS) Transverse",0x1,0x2c6f0,0x3ebe8,0x0,0x0,0x2c6f0,0x3ebe8},
143 {"A3 Extra",0x1,0x4e9d0,0x6ca48,0x0,0x0,0x4e9d0,0x6ca48},
144 {"A5 Extra",0x1,0x2a7b0,0x395f8,0x0,0x0,0x2a7b0,0x395f8},
145 {"B5 (ISO) Extra",0x1,0x31128,0x43620,0x0,0x0,0x31128,0x43620},
146 {"A2",0x1,0x668a0,0x91050,0x0,0x0,0x668a0,0x91050},
147 {"A3 Transverse",0x1,0x48828,0x668a0,0x0,0x0,0x48828,0x668a0},
148 {"A3 Extra Transverse",0x1,0x4e9d0,0x6ca48,0x0,0x0,0x4e9d0,0x6ca48},
149 {"Japanese Double Postcard",0x1,0x30d40,0x24220,0x0,0x0,0x30d40,0x24220},
150 {"A6",0x1,0x19a28,0x24220,0x0,0x0,0x19a28,0x24220},
151 {"Japanese Envelope Kaku #2",0x1,0x3a980,0x510e0,0x0,0x0,0x3a980,0x510e0},
152 {"Japanese Envelope Kaku #3",0x1,0x34bc0,0x43a08,0x0,0x0,0x34bc0,0x43a08},
153 {"Japanese Envelope Chou #3",0x1,0x1d4c0,0x395f8,0x0,0x0,0x1d4c0,0x395f8},
154 {"Japanese Envelope Chou #4",0x1,0x15f90,0x320c8,0x0,0x0,0x15f90,0x320c8},
155 {"Letter Rotated",0x1,0x44368,0x34b5c,0x0,0x0,0x44368,0x34b5c},
156 {"A3 Rotated",0x1,0x668a0,0x48828,0x0,0x0,0x668a0,0x48828},
157 {"A4 Rotated",0x1,0x48828,0x33450,0x0,0x0,0x48828,0x33450},
158 {"A5 Rotated",0x1,0x33450,0x24220,0x0,0x0,0x33450,0x24220},
159 {"B4 (JIS) Rotated",0x1,0x58de0,0x3ebe8,0x0,0x0,0x58de0,0x3ebe8},
160 {"B5 (JIS) Rotated",0x1,0x3ebe8,0x2c6f0,0x0,0x0,0x3ebe8,0x2c6f0},
161 {"Japanese Postcard Rotated",0x1,0x24220,0x186a0,0x0,0x0,0x24220,0x186a0},
162 {"Double Japan Postcard Rotated",0x1,0x24220,0x30d40,0x0,0x0,0x24220,0x30d40},
163 {"A6 Rotated",0x1,0x24220,0x19a28,0x0,0x0,0x24220,0x19a28},
164 {"Japan Envelope Kaku #2 Rotated",0x1,0x510e0,0x3a980,0x0,0x0,0x510e0,0x3a980},
165 {"Japan Envelope Kaku #3 Rotated",0x1,0x43a08,0x34bc0,0x0,0x0,0x43a08, 0x34bc0},
166 {"Japan Envelope Chou #3 Rotated",0x1,0x395f8,0x1d4c0,0x0,0x0,0x395f8,0x1d4c0},
167 {"Japan Envelope Chou #4 Rotated",0x1,0x320c8,0x15f90,0x0,0x0,0x320c8,0x15f90},
168 {"B6 (JIS)",0x1,0x1f400,0x2c6f0,0x0,0x0,0x1f400,0x2c6f0},
169 {"B6 (JIS) Rotated",0x1,0x2c6f0,0x1f400,0x0,0x0,0x2c6f0,0x1f400},
170 {"12x11",0x1,0x4a724,0x443e1,0x0,0x0,0x4a724,0x443e1},
171 {"Japan Envelope You #4",0x1,0x19a28,0x395f8,0x0,0x0,0x19a28,0x395f8},
172 {"Japan Envelope You #4 Rotated",0x1,0x395f8,0x19a28,0x0,0x0,0x395f8,0x19a28},
173 {"PRC 16K",0x1,0x2de60,0x3f7a0,0x0,0x0,0x2de60,0x3f7a0},
174 {"PRC 32K",0x1,0x1fbd0,0x2cec0,0x0,0x0,0x1fbd0,0x2cec0},
175 {"PRC 32K(Big)",0x1,0x222e0,0x318f8,0x0,0x0,0x222e0,0x318f8},
176 {"PRC Envelope #1",0x1,0x18e70,0x28488,0x0,0x0,0x18e70,0x28488},
177 {"PRC Envelope #2",0x1,0x18e70,0x2af80,0x0,0x0,0x18e70,0x2af80},
178 {"PRC Envelope #3",0x1,0x1e848,0x2af80,0x0,0x0,0x1e848,0x2af80},
179 {"PRC Envelope #4",0x1,0x1adb0,0x32c80,0x0,0x0,0x1adb0,0x32c80},
180 {"PRC Envelope #5",0x1,0x1adb0,0x35b60,0x0,0x0,0x1adb0,0x35b60},
181 {"PRC Envelope #6",0x1,0x1d4c0,0x38270,0x0,0x0,0x1d4c0,0x38270},
182 {"PRC Envelope #7",0x1,0x27100,0x38270,0x0,0x0,0x27100,0x38270},
183 {"PRC Envelope #8",0x1,0x1d4c0,0x4b708,0x0,0x0,0x1d4c0,0x4b708},
184 {"PRC Envelope #9",0x1,0x37e88,0x4f1a0,0x0,0x0,0x37e88,0x4f1a0},
185 {"PRC Envelope #10",0x1,0x4f1a0,0x6fd10,0x0,0x0,0x4f1a0,0x6fd10},
186 {"PRC 16K Rotated",0x1,0x3f7a0,0x2de60,0x0,0x0,0x3f7a0,0x2de60},
187 {"PRC 32K Rotated",0x1,0x2cec0,0x1fbd0,0x0,0x0,0x2cec0,0x1fbd0},
188 {"PRC 32K(Big) Rotated",0x1,0x318f8,0x222e0,0x0,0x0,0x318f8,0x222e0},
189 {"PRC Envelope #1 Rotated",0x1,0x28488,0x18e70,0x0,0x0,0x28488,0x18e70},
190 {"PRC Envelope #2 Rotated",0x1,0x2af80,0x18e70,0x0,0x0,0x2af80,0x18e70},
191 {"PRC Envelope #3 Rotated",0x1,0x2af80,0x1e848,0x0,0x0,0x2af80,0x1e848},
192 {"PRC Envelope #4 Rotated",0x1,0x32c80,0x1adb0,0x0,0x0,0x32c80,0x1adb0},
193 {"PRC Envelope #5 Rotated",0x1,0x35b60,0x1adb0,0x0,0x0,0x35b60,0x1adb0},
194 {"PRC Envelope #6 Rotated",0x1,0x38270,0x1d4c0,0x0,0x0,0x38270,0x1d4c0},
195 {"PRC Envelope #7 Rotated",0x1,0x38270,0x27100,0x0,0x0,0x38270,0x27100},
196 {"PRC Envelope #8 Rotated",0x1,0x4b708,0x1d4c0,0x0,0x0,0x4b708,0x1d4c0},
197 {"PRC Envelope #9 Rotated",0x1,0x4f1a0,0x37e88,0x0,0x0,0x4f1a0,0x37e88},
198 {"PRC Envelope #10 Rotated",0x1,0x6fd10,0x4f1a0,0x0,0x0,0x6fd10,0x4f1a0}
202 const char *long_archi
;
203 const char *short_archi
;
207 #define SPL_ARCH_WIN40 "WIN40"
208 #define SPL_ARCH_W32X86 "W32X86"
209 #define SPL_ARCH_W32MIPS "W32MIPS"
210 #define SPL_ARCH_W32ALPHA "W32ALPHA"
211 #define SPL_ARCH_W32PPC "W32PPC"
212 #define SPL_ARCH_IA64 "IA64"
213 #define SPL_ARCH_X64 "x64"
215 static const struct table_node archi_table
[]= {
217 {"Windows 4.0", SPL_ARCH_WIN40
, 0 },
218 {"Windows NT x86", SPL_ARCH_W32X86
, 2 },
219 {"Windows NT R4000", SPL_ARCH_W32MIPS
, 2 },
220 {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA
, 2 },
221 {"Windows NT PowerPC", SPL_ARCH_W32PPC
, 2 },
222 {"Windows IA64", SPL_ARCH_IA64
, 3 },
223 {"Windows x64", SPL_ARCH_X64
, 3 },
228 /****************************************************************************
229 generate a new TDB_DATA key for storing a printer
230 ****************************************************************************/
232 static TDB_DATA
make_printer_tdbkey( const char *sharename
)
235 static pstring keystr
;
238 fstrcpy( share
, sharename
);
241 pstr_sprintf( keystr
, "%s%s", PRINTERS_PREFIX
, share
);
244 key
.dsize
= strlen(keystr
)+1;
249 /****************************************************************************
250 generate a new TDB_DATA key for storing a printer security descriptor
251 ****************************************************************************/
253 static char *make_printers_secdesc_tdbkey( const char* sharename
)
256 static pstring keystr
;
258 fstrcpy( share
, sharename
);
261 pstr_sprintf( keystr
, "%s%s", SECDESC_PREFIX
, share
);
266 /****************************************************************************
267 ****************************************************************************/
269 static BOOL
upgrade_to_version_3(void)
271 TDB_DATA kbuf
, newkey
, dbuf
;
273 DEBUG(0,("upgrade_to_version_3: upgrading print tdb's to version 3\n"));
275 for (kbuf
= tdb_firstkey(tdb_drivers
); kbuf
.dptr
;
276 newkey
= tdb_nextkey(tdb_drivers
, kbuf
), safe_free(kbuf
.dptr
), kbuf
=newkey
) {
278 dbuf
= tdb_fetch(tdb_drivers
, kbuf
);
280 if (strncmp(kbuf
.dptr
, FORMS_PREFIX
, strlen(FORMS_PREFIX
)) == 0) {
281 DEBUG(0,("upgrade_to_version_3:moving form\n"));
282 if (tdb_store(tdb_forms
, kbuf
, dbuf
, TDB_REPLACE
) != 0) {
283 SAFE_FREE(dbuf
.dptr
);
284 DEBUG(0,("upgrade_to_version_3: failed to move form. Error (%s).\n", tdb_errorstr(tdb_forms
)));
287 if (tdb_delete(tdb_drivers
, kbuf
) != 0) {
288 SAFE_FREE(dbuf
.dptr
);
289 DEBUG(0,("upgrade_to_version_3: failed to delete form. Error (%s)\n", tdb_errorstr(tdb_drivers
)));
294 if (strncmp(kbuf
.dptr
, PRINTERS_PREFIX
, strlen(PRINTERS_PREFIX
)) == 0) {
295 DEBUG(0,("upgrade_to_version_3:moving printer\n"));
296 if (tdb_store(tdb_printers
, kbuf
, dbuf
, TDB_REPLACE
) != 0) {
297 SAFE_FREE(dbuf
.dptr
);
298 DEBUG(0,("upgrade_to_version_3: failed to move printer. Error (%s)\n", tdb_errorstr(tdb_printers
)));
301 if (tdb_delete(tdb_drivers
, kbuf
) != 0) {
302 SAFE_FREE(dbuf
.dptr
);
303 DEBUG(0,("upgrade_to_version_3: failed to delete printer. Error (%s)\n", tdb_errorstr(tdb_drivers
)));
308 if (strncmp(kbuf
.dptr
, SECDESC_PREFIX
, strlen(SECDESC_PREFIX
)) == 0) {
309 DEBUG(0,("upgrade_to_version_3:moving secdesc\n"));
310 if (tdb_store(tdb_printers
, kbuf
, dbuf
, TDB_REPLACE
) != 0) {
311 SAFE_FREE(dbuf
.dptr
);
312 DEBUG(0,("upgrade_to_version_3: failed to move secdesc. Error (%s)\n", tdb_errorstr(tdb_printers
)));
315 if (tdb_delete(tdb_drivers
, kbuf
) != 0) {
316 SAFE_FREE(dbuf
.dptr
);
317 DEBUG(0,("upgrade_to_version_3: failed to delete secdesc. Error (%s)\n", tdb_errorstr(tdb_drivers
)));
322 SAFE_FREE(dbuf
.dptr
);
328 /*******************************************************************
329 Fix an issue with security descriptors. Printer sec_desc must
330 use more than the generic bits that were previously used
331 in <= 3.0.14a. They must also have a owner and group SID assigned.
332 Otherwise, any printers than have been migrated to a Windows
333 host using printmig.exe will not be accessible.
334 *******************************************************************/
336 static int sec_desc_upg_fn( TDB_CONTEXT
*the_tdb
, TDB_DATA key
,
337 TDB_DATA data
, void *state
)
340 SEC_DESC_BUF
*sd_orig
= NULL
;
341 SEC_DESC_BUF
*sd_new
, *sd_store
;
342 SEC_DESC
*sec
, *new_sec
;
343 TALLOC_CTX
*ctx
= state
;
349 if (!data
.dptr
|| data
.dsize
== 0) {
353 if ( strncmp( key
.dptr
, SECDESC_PREFIX
, strlen(SECDESC_PREFIX
) ) != 0 ) {
357 /* upgrade the security descriptor */
361 prs_init( &ps
, 0, ctx
, UNMARSHALL
);
362 prs_give_memory( &ps
, data
.dptr
, data
.dsize
, False
);
364 if ( !sec_io_desc_buf( "sec_desc_upg_fn", &sd_orig
, &ps
, 1 ) ) {
365 /* delete bad entries */
366 DEBUG(0,("sec_desc_upg_fn: Failed to parse original sec_desc for %si. Deleting....\n", key
.dptr
));
367 tdb_delete( tdb_printers
, key
);
378 /* is this even valid? */
385 /* update access masks */
387 for ( i
=0; i
<sec
->dacl
->num_aces
; i
++ ) {
388 switch ( sec
->dacl
->ace
[i
].info
.mask
) {
389 case (GENERIC_READ_ACCESS
| GENERIC_WRITE_ACCESS
| GENERIC_EXECUTE_ACCESS
):
390 sec
->dacl
->ace
[i
].info
.mask
= PRINTER_ACE_PRINT
;
393 case GENERIC_ALL_ACCESS
:
394 sec
->dacl
->ace
[i
].info
.mask
= PRINTER_ACE_FULL_CONTROL
;
397 case READ_CONTROL_ACCESS
:
398 sec
->dacl
->ace
[i
].info
.mask
= PRINTER_ACE_MANAGE_DOCUMENTS
;
400 default: /* no change */
405 /* create a new SEC_DESC with the appropriate owner and group SIDs */
407 string_to_sid(&sid
, "S-1-5-32-544" );
408 new_sec
= make_sec_desc( ctx
, SEC_DESC_REVISION
, SEC_DESC_SELF_RELATIVE
,
410 NULL
, NULL
, &size_new_sec
);
415 sd_new
= make_sec_desc_buf( ctx
, size_new_sec
, new_sec
);
421 if ( !(sd_store
= sec_desc_merge( ctx
, sd_new
, sd_orig
)) ) {
422 DEBUG(0,("sec_desc_upg_fn: Failed to update sec_desc for %s\n", key
.dptr
));
431 sd_size
= sec_desc_size(sd_store
->sec
) + sizeof(SEC_DESC_BUF
);
432 prs_init(&ps
, sd_size
, ctx
, MARSHALL
);
434 if ( !sec_io_desc_buf( "sec_desc_upg_fn", &sd_store
, &ps
, 1 ) ) {
435 DEBUG(0,("sec_desc_upg_fn: Failed to parse new sec_desc for %s\n", key
.dptr
));
440 data
.dptr
= prs_data_p( &ps
);
441 data
.dsize
= sd_size
;
443 result
= tdb_store( tdb_printers
, key
, data
, TDB_REPLACE
);
447 /* 0 to continue and non-zero to stop traversal */
449 return (result
== -1);
452 /*******************************************************************
453 *******************************************************************/
455 static BOOL
upgrade_to_version_4(void)
460 DEBUG(0,("upgrade_to_version_4: upgrading printer security descriptors\n"));
462 if ( !(ctx
= talloc_init( "upgrade_to_version_4" )) )
465 result
= tdb_traverse( tdb_printers
, sec_desc_upg_fn
, ctx
);
467 talloc_destroy( ctx
);
469 return ( result
!= -1 );
472 /*******************************************************************
473 Fix an issue with security descriptors. Printer sec_desc must
474 use more than the generic bits that were previously used
475 in <= 3.0.14a. They must also have a owner and group SID assigned.
476 Otherwise, any printers than have been migrated to a Windows
477 host using printmig.exe will not be accessible.
478 *******************************************************************/
480 static int normalize_printers_fn( TDB_CONTEXT
*the_tdb
, TDB_DATA key
,
481 TDB_DATA data
, void *state
)
485 if (!data
.dptr
|| data
.dsize
== 0)
488 /* upgrade printer records and security descriptors */
490 if ( strncmp( key
.dptr
, PRINTERS_PREFIX
, strlen(PRINTERS_PREFIX
) ) == 0 ) {
491 new_key
= make_printer_tdbkey( key
.dptr
+strlen(PRINTERS_PREFIX
) );
493 else if ( strncmp( key
.dptr
, SECDESC_PREFIX
, strlen(SECDESC_PREFIX
) ) == 0 ) {
494 new_key
.dptr
= make_printers_secdesc_tdbkey( key
.dptr
+strlen(SECDESC_PREFIX
) );
495 new_key
.dsize
= strlen( new_key
.dptr
) + 1;
498 /* ignore this record */
502 /* delete the original record and store under the normalized key */
504 if ( tdb_delete( the_tdb
, key
) != 0 ) {
505 DEBUG(0,("normalize_printers_fn: tdb_delete for [%s] failed!\n",
510 if ( tdb_store( the_tdb
, new_key
, data
, TDB_REPLACE
) != 0 ) {
511 DEBUG(0,("normalize_printers_fn: failed to store new record for [%s]!\n",
519 /*******************************************************************
520 *******************************************************************/
522 static BOOL
upgrade_to_version_5(void)
527 DEBUG(0,("upgrade_to_version_5: normalizing printer keys\n"));
529 if ( !(ctx
= talloc_init( "upgrade_to_version_5" )) )
532 result
= tdb_traverse( tdb_printers
, normalize_printers_fn
, NULL
);
534 talloc_destroy( ctx
);
536 return ( result
!= -1 );
539 /****************************************************************************
540 Open the NT printing tdbs. Done once before fork().
541 ****************************************************************************/
543 BOOL
nt_printing_init(void)
545 const char *vstring
= "INFO/version";
549 if ( tdb_drivers
&& tdb_printers
&& tdb_forms
)
553 tdb_close(tdb_drivers
);
554 tdb_drivers
= tdb_open_log(lock_path("ntdrivers.tdb"), 0, TDB_DEFAULT
, O_RDWR
|O_CREAT
, 0600);
556 DEBUG(0,("nt_printing_init: Failed to open nt drivers database %s (%s)\n",
557 lock_path("ntdrivers.tdb"), strerror(errno
) ));
562 tdb_close(tdb_printers
);
563 tdb_printers
= tdb_open_log(lock_path("ntprinters.tdb"), 0, TDB_DEFAULT
, O_RDWR
|O_CREAT
, 0600);
565 DEBUG(0,("nt_printing_init: Failed to open nt printers database %s (%s)\n",
566 lock_path("ntprinters.tdb"), strerror(errno
) ));
571 tdb_close(tdb_forms
);
572 tdb_forms
= tdb_open_log(lock_path("ntforms.tdb"), 0, TDB_DEFAULT
, O_RDWR
|O_CREAT
, 0600);
574 DEBUG(0,("nt_printing_init: Failed to open nt forms database %s (%s)\n",
575 lock_path("ntforms.tdb"), strerror(errno
) ));
579 /* handle a Samba upgrade */
581 vers_id
= tdb_fetch_int32(tdb_drivers
, vstring
);
583 DEBUG(10, ("Fresh database\n"));
584 tdb_store_int32( tdb_drivers
, vstring
, NTDRIVERS_DATABASE_VERSION_5
);
585 vers_id
= NTDRIVERS_DATABASE_VERSION_5
;
588 if ( vers_id
!= NTDRIVERS_DATABASE_VERSION_5
) {
590 if ((vers_id
== NTDRIVERS_DATABASE_VERSION_1
) || (IREV(vers_id
) == NTDRIVERS_DATABASE_VERSION_1
)) {
591 if (!upgrade_to_version_3())
593 tdb_store_int32(tdb_drivers
, vstring
, NTDRIVERS_DATABASE_VERSION_3
);
594 vers_id
= NTDRIVERS_DATABASE_VERSION_3
;
597 if ((vers_id
== NTDRIVERS_DATABASE_VERSION_2
) || (IREV(vers_id
) == NTDRIVERS_DATABASE_VERSION_2
)) {
598 /* Written on a bigendian machine with old fetch_int code. Save as le. */
599 /* The only upgrade between V2 and V3 is to save the version in little-endian. */
600 tdb_store_int32(tdb_drivers
, vstring
, NTDRIVERS_DATABASE_VERSION_3
);
601 vers_id
= NTDRIVERS_DATABASE_VERSION_3
;
604 if (vers_id
== NTDRIVERS_DATABASE_VERSION_3
) {
605 if ( !upgrade_to_version_4() )
607 tdb_store_int32(tdb_drivers
, vstring
, NTDRIVERS_DATABASE_VERSION_4
);
608 vers_id
= NTDRIVERS_DATABASE_VERSION_4
;
611 if (vers_id
== NTDRIVERS_DATABASE_VERSION_4
) {
612 if ( !upgrade_to_version_5() )
614 tdb_store_int32(tdb_drivers
, vstring
, NTDRIVERS_DATABASE_VERSION_5
);
615 vers_id
= NTDRIVERS_DATABASE_VERSION_5
;
619 if ( vers_id
!= NTDRIVERS_DATABASE_VERSION_5
) {
620 DEBUG(0,("nt_printing_init: Unknown printer database version [%d]\n", vers_id
));
625 update_c_setprinter(True
);
628 * register callback to handle updating printers as new
629 * drivers are installed
632 message_register( MSG_PRINTER_DRVUPGRADE
, do_drv_upgrade_printer
);
635 * register callback to handle updating printer data
636 * when a driver is initialized
639 message_register( MSG_PRINTERDATA_INIT_RESET
, reset_all_printerdata
);
641 /* of course, none of the message callbacks matter if you don't
642 tell messages.c that you interested in receiving PRINT_GENERAL
643 msgs. This is done in claim_connection() */
646 if ( lp_security() == SEC_ADS
) {
647 win_rc
= check_published_printers();
648 if (!W_ERROR_IS_OK(win_rc
))
649 DEBUG(0, ("nt_printing_init: error checking published printers: %s\n", dos_errstr(win_rc
)));
655 /*******************************************************************
656 Function to allow filename parsing "the old way".
657 ********************************************************************/
659 static BOOL
driver_unix_convert(char *name
,connection_struct
*conn
,
660 char *saved_last_component
, BOOL
*bad_path
, SMB_STRUCT_STAT
*pst
)
663 unix_clean_name(name
);
664 trim_string(name
,"/","/");
665 return unix_convert(name
, conn
, saved_last_component
, bad_path
, pst
);
668 /*******************************************************************
669 tdb traversal function for counting printers.
670 ********************************************************************/
672 static int traverse_counting_printers(TDB_CONTEXT
*t
, TDB_DATA key
,
673 TDB_DATA data
, void *context
)
675 int *printer_count
= (int*)context
;
677 if (memcmp(PRINTERS_PREFIX
, key
.dptr
, sizeof(PRINTERS_PREFIX
)-1) == 0) {
679 DEBUG(10,("traverse_counting_printers: printer = [%s] printer_count = %d\n", key
.dptr
, *printer_count
));
685 /*******************************************************************
686 Update the spooler global c_setprinter. This variable is initialized
687 when the parent smbd starts with the number of existing printers. It
688 is monotonically increased by the current number of printers *after*
689 each add or delete printer RPC. Only Microsoft knows why... JRR020119
690 ********************************************************************/
692 uint32
update_c_setprinter(BOOL initialize
)
695 int32 printer_count
= 0;
697 tdb_lock_bystring(tdb_printers
, GLOBAL_C_SETPRINTER
);
699 /* Traverse the tdb, counting the printers */
700 tdb_traverse(tdb_printers
, traverse_counting_printers
, (void *)&printer_count
);
702 /* If initializing, set c_setprinter to current printers count
703 * otherwise, bump it by the current printer count
706 c_setprinter
= tdb_fetch_int32(tdb_printers
, GLOBAL_C_SETPRINTER
) + printer_count
;
708 c_setprinter
= printer_count
;
710 DEBUG(10,("update_c_setprinter: c_setprinter = %u\n", (unsigned int)c_setprinter
));
711 tdb_store_int32(tdb_printers
, GLOBAL_C_SETPRINTER
, c_setprinter
);
713 tdb_unlock_bystring(tdb_printers
, GLOBAL_C_SETPRINTER
);
715 return (uint32
)c_setprinter
;
718 /*******************************************************************
719 Get the spooler global c_setprinter, accounting for initialization.
720 ********************************************************************/
722 uint32
get_c_setprinter(void)
724 int32 c_setprinter
= tdb_fetch_int32(tdb_printers
, GLOBAL_C_SETPRINTER
);
726 if (c_setprinter
== (int32
)-1)
727 c_setprinter
= update_c_setprinter(True
);
729 DEBUG(10,("get_c_setprinter: c_setprinter = %d\n", c_setprinter
));
731 return (uint32
)c_setprinter
;
734 /****************************************************************************
735 Get builtin form struct list.
736 ****************************************************************************/
738 int get_builtin_ntforms(nt_forms_struct
**list
)
740 *list
= (nt_forms_struct
*)memdup(&default_forms
[0], sizeof(default_forms
));
741 return sizeof(default_forms
) / sizeof(default_forms
[0]);
744 /****************************************************************************
745 get a builtin form struct
746 ****************************************************************************/
748 BOOL
get_a_builtin_ntform(UNISTR2
*uni_formname
,nt_forms_struct
*form
)
752 unistr2_to_ascii(form_name
, uni_formname
, sizeof(form_name
)-1);
753 DEBUGADD(6,("Looking for builtin form %s \n", form_name
));
754 count
= sizeof(default_forms
) / sizeof(default_forms
[0]);
755 for (i
=0;i
<count
;i
++) {
756 if (strequal(form_name
,default_forms
[i
].name
)) {
757 DEBUGADD(6,("Found builtin form %s \n", form_name
));
758 memcpy(form
,&default_forms
[i
],sizeof(*form
));
766 /****************************************************************************
767 get a form struct list.
768 ****************************************************************************/
770 int get_ntforms(nt_forms_struct
**list
)
772 TDB_DATA kbuf
, newkey
, dbuf
;
773 nt_forms_struct form
;
780 for (kbuf
= tdb_firstkey(tdb_forms
);
782 newkey
= tdb_nextkey(tdb_forms
, kbuf
), safe_free(kbuf
.dptr
), kbuf
=newkey
)
784 if (strncmp(kbuf
.dptr
, FORMS_PREFIX
, strlen(FORMS_PREFIX
)) != 0)
787 dbuf
= tdb_fetch(tdb_forms
, kbuf
);
791 fstrcpy(form
.name
, kbuf
.dptr
+strlen(FORMS_PREFIX
));
792 ret
= tdb_unpack(dbuf
.dptr
, dbuf
.dsize
, "dddddddd",
793 &i
, &form
.flag
, &form
.width
, &form
.length
, &form
.left
,
794 &form
.top
, &form
.right
, &form
.bottom
);
795 SAFE_FREE(dbuf
.dptr
);
796 if (ret
!= dbuf
.dsize
)
799 *list
= SMB_REALLOC_ARRAY(*list
, nt_forms_struct
, n
+1);
801 DEBUG(0,("get_ntforms: Realloc fail.\n"));
812 /****************************************************************************
813 write a form struct list
814 ****************************************************************************/
815 int write_ntforms(nt_forms_struct
**list
, int number
)
822 for (i
=0;i
<number
;i
++) {
823 /* save index, so list is rebuilt in correct order */
824 len
= tdb_pack(buf
, sizeof(buf
), "dddddddd",
825 i
, (*list
)[i
].flag
, (*list
)[i
].width
, (*list
)[i
].length
,
826 (*list
)[i
].left
, (*list
)[i
].top
, (*list
)[i
].right
,
828 if (len
> sizeof(buf
)) break;
829 slprintf(key
, sizeof(key
)-1, "%s%s", FORMS_PREFIX
, (*list
)[i
].name
);
830 kbuf
.dsize
= strlen(key
)+1;
834 if (tdb_store(tdb_forms
, kbuf
, dbuf
, TDB_REPLACE
) != 0) break;
840 /****************************************************************************
841 add a form struct at the end of the list
842 ****************************************************************************/
843 BOOL
add_a_form(nt_forms_struct
**list
, const FORM
*form
, int *count
)
850 * NT tries to add forms even when
851 * they are already in the base
852 * only update the values if already present
857 unistr2_to_ascii(form_name
, &form
->name
, sizeof(form_name
)-1);
858 for (n
=0; n
<*count
; n
++) {
859 if ( strequal((*list
)[n
].name
, form_name
) ) {
866 if((*list
=SMB_REALLOC_ARRAY(*list
, nt_forms_struct
, n
+1)) == NULL
) {
867 DEBUG(0,("add_a_form: failed to enlarge forms list!\n"));
870 unistr2_to_ascii((*list
)[n
].name
, &form
->name
, sizeof((*list
)[n
].name
)-1);
874 (*list
)[n
].flag
=form
->flags
;
875 (*list
)[n
].width
=form
->size_x
;
876 (*list
)[n
].length
=form
->size_y
;
877 (*list
)[n
].left
=form
->left
;
878 (*list
)[n
].top
=form
->top
;
879 (*list
)[n
].right
=form
->right
;
880 (*list
)[n
].bottom
=form
->bottom
;
882 DEBUG(6,("add_a_form: Successfully %s form [%s]\n",
883 update
? "updated" : "added", form_name
));
888 /****************************************************************************
889 Delete a named form struct.
890 ****************************************************************************/
892 BOOL
delete_a_form(nt_forms_struct
**list
, UNISTR2
*del_name
, int *count
, WERROR
*ret
)
901 unistr2_to_ascii(form_name
, del_name
, sizeof(form_name
)-1);
903 for (n
=0; n
<*count
; n
++) {
904 if (!strncmp((*list
)[n
].name
, form_name
, strlen(form_name
))) {
905 DEBUG(103, ("delete_a_form, [%s] in list\n", form_name
));
911 DEBUG(10,("delete_a_form, [%s] not found\n", form_name
));
912 *ret
= WERR_INVALID_PARAM
;
916 slprintf(key
, sizeof(key
)-1, "%s%s", FORMS_PREFIX
, (*list
)[n
].name
);
917 kbuf
.dsize
= strlen(key
)+1;
919 if (tdb_delete(tdb_forms
, kbuf
) != 0) {
927 /****************************************************************************
928 Update a form struct.
929 ****************************************************************************/
931 void update_a_form(nt_forms_struct
**list
, const FORM
*form
, int count
)
935 unistr2_to_ascii(form_name
, &(form
->name
), sizeof(form_name
)-1);
937 DEBUG(106, ("[%s]\n", form_name
));
938 for (n
=0; n
<count
; n
++) {
939 DEBUGADD(106, ("n [%d]:[%s]\n", n
, (*list
)[n
].name
));
940 if (!strncmp((*list
)[n
].name
, form_name
, strlen(form_name
)))
944 if (n
==count
) return;
946 (*list
)[n
].flag
=form
->flags
;
947 (*list
)[n
].width
=form
->size_x
;
948 (*list
)[n
].length
=form
->size_y
;
949 (*list
)[n
].left
=form
->left
;
950 (*list
)[n
].top
=form
->top
;
951 (*list
)[n
].right
=form
->right
;
952 (*list
)[n
].bottom
=form
->bottom
;
955 /****************************************************************************
956 Get the nt drivers list.
957 Traverse the database and look-up the matching names.
958 ****************************************************************************/
959 int get_ntdrivers(fstring
**list
, const char *architecture
, uint32 version
)
962 const char *short_archi
;
964 TDB_DATA kbuf
, newkey
;
966 short_archi
= get_short_archi(architecture
);
971 slprintf(key
, sizeof(key
)-1, "%s%s/%d/", DRIVERS_PREFIX
, short_archi
, version
);
973 for (kbuf
= tdb_firstkey(tdb_drivers
);
975 newkey
= tdb_nextkey(tdb_drivers
, kbuf
), safe_free(kbuf
.dptr
), kbuf
=newkey
) {
977 if (strncmp(kbuf
.dptr
, key
, strlen(key
)) != 0)
980 if((*list
= SMB_REALLOC_ARRAY(*list
, fstring
, total
+1)) == NULL
) {
981 DEBUG(0,("get_ntdrivers: failed to enlarge list!\n"));
985 fstrcpy((*list
)[total
], kbuf
.dptr
+strlen(key
));
992 /****************************************************************************
993 Function to do the mapping between the long architecture name and
995 ****************************************************************************/
997 const char *get_short_archi(const char *long_archi
)
1001 DEBUG(107,("Getting architecture dependant directory\n"));
1004 } while ( (archi_table
[i
].long_archi
!=NULL
) &&
1005 StrCaseCmp(long_archi
, archi_table
[i
].long_archi
) );
1007 if (archi_table
[i
].long_archi
==NULL
) {
1008 DEBUGADD(10,("Unknown architecture [%s] !\n", long_archi
));
1012 /* this might be client code - but shouldn't this be an fstrcpy etc? */
1014 DEBUGADD(108,("index: [%d]\n", i
));
1015 DEBUGADD(108,("long architecture: [%s]\n", archi_table
[i
].long_archi
));
1016 DEBUGADD(108,("short architecture: [%s]\n", archi_table
[i
].short_archi
));
1018 return archi_table
[i
].short_archi
;
1021 /****************************************************************************
1022 Version information in Microsoft files is held in a VS_VERSION_INFO structure.
1023 There are two case to be covered here: PE (Portable Executable) and NE (New
1024 Executable) files. Both files support the same INFO structure, but PE files
1025 store the signature in unicode, and NE files store it as !unicode.
1026 returns -1 on error, 1 on version info found, and 0 on no version info found.
1027 ****************************************************************************/
1029 static int get_file_version(files_struct
*fsp
, char *fname
,uint32
*major
, uint32
*minor
)
1035 if ((buf
=SMB_MALLOC(PE_HEADER_SIZE
)) == NULL
) {
1036 DEBUG(0,("get_file_version: PE file [%s] PE Header malloc failed bytes = %d\n",
1037 fname
, PE_HEADER_SIZE
));
1041 /* Note: DOS_HEADER_SIZE < malloc'ed PE_HEADER_SIZE */
1042 if ((byte_count
= vfs_read_data(fsp
, buf
, DOS_HEADER_SIZE
)) < DOS_HEADER_SIZE
) {
1043 DEBUG(3,("get_file_version: File [%s] DOS header too short, bytes read = %lu\n",
1044 fname
, (unsigned long)byte_count
));
1045 goto no_version_info
;
1048 /* Is this really a DOS header? */
1049 if (SVAL(buf
,DOS_HEADER_MAGIC_OFFSET
) != DOS_HEADER_MAGIC
) {
1050 DEBUG(6,("get_file_version: File [%s] bad DOS magic = 0x%x\n",
1051 fname
, SVAL(buf
,DOS_HEADER_MAGIC_OFFSET
)));
1052 goto no_version_info
;
1055 /* Skip OEM header (if any) and the DOS stub to start of Windows header */
1056 if (SMB_VFS_LSEEK(fsp
, fsp
->fh
->fd
, SVAL(buf
,DOS_HEADER_LFANEW_OFFSET
), SEEK_SET
) == (SMB_OFF_T
)-1) {
1057 DEBUG(3,("get_file_version: File [%s] too short, errno = %d\n",
1059 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
1060 goto no_version_info
;
1063 if ((byte_count
= vfs_read_data(fsp
, buf
, PE_HEADER_SIZE
)) < PE_HEADER_SIZE
) {
1064 DEBUG(3,("get_file_version: File [%s] Windows header too short, bytes read = %lu\n",
1065 fname
, (unsigned long)byte_count
));
1066 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
1067 goto no_version_info
;
1070 /* The header may be a PE (Portable Executable) or an NE (New Executable) */
1071 if (IVAL(buf
,PE_HEADER_SIGNATURE_OFFSET
) == PE_HEADER_SIGNATURE
) {
1072 unsigned int num_sections
;
1073 unsigned int section_table_bytes
;
1075 if (SVAL(buf
,PE_HEADER_MACHINE_OFFSET
) != PE_HEADER_MACHINE_I386
) {
1076 DEBUG(3,("get_file_version: PE file [%s] wrong machine = 0x%x\n",
1077 fname
, SVAL(buf
,PE_HEADER_MACHINE_OFFSET
)));
1078 /* At this point, we assume the file is in error. It still could be somthing
1079 * else besides a PE file, but it unlikely at this point.
1084 /* get the section table */
1085 num_sections
= SVAL(buf
,PE_HEADER_NUMBER_OF_SECTIONS
);
1086 section_table_bytes
= num_sections
* PE_HEADER_SECT_HEADER_SIZE
;
1087 if (section_table_bytes
== 0)
1091 if ((buf
=SMB_MALLOC(section_table_bytes
)) == NULL
) {
1092 DEBUG(0,("get_file_version: PE file [%s] section table malloc failed bytes = %d\n",
1093 fname
, section_table_bytes
));
1097 if ((byte_count
= vfs_read_data(fsp
, buf
, section_table_bytes
)) < section_table_bytes
) {
1098 DEBUG(3,("get_file_version: PE file [%s] Section header too short, bytes read = %lu\n",
1099 fname
, (unsigned long)byte_count
));
1103 /* Iterate the section table looking for the resource section ".rsrc" */
1104 for (i
= 0; i
< num_sections
; i
++) {
1105 int sec_offset
= i
* PE_HEADER_SECT_HEADER_SIZE
;
1107 if (strcmp(".rsrc", &buf
[sec_offset
+PE_HEADER_SECT_NAME_OFFSET
]) == 0) {
1108 unsigned int section_pos
= IVAL(buf
,sec_offset
+PE_HEADER_SECT_PTR_DATA_OFFSET
);
1109 unsigned int section_bytes
= IVAL(buf
,sec_offset
+PE_HEADER_SECT_SIZE_DATA_OFFSET
);
1111 if (section_bytes
== 0)
1115 if ((buf
=SMB_MALLOC(section_bytes
)) == NULL
) {
1116 DEBUG(0,("get_file_version: PE file [%s] version malloc failed bytes = %d\n",
1117 fname
, section_bytes
));
1121 /* Seek to the start of the .rsrc section info */
1122 if (SMB_VFS_LSEEK(fsp
, fsp
->fh
->fd
, section_pos
, SEEK_SET
) == (SMB_OFF_T
)-1) {
1123 DEBUG(3,("get_file_version: PE file [%s] too short for section info, errno = %d\n",
1128 if ((byte_count
= vfs_read_data(fsp
, buf
, section_bytes
)) < section_bytes
) {
1129 DEBUG(3,("get_file_version: PE file [%s] .rsrc section too short, bytes read = %lu\n",
1130 fname
, (unsigned long)byte_count
));
1134 if (section_bytes
< VS_VERSION_INFO_UNICODE_SIZE
)
1137 for (i
=0; i
<section_bytes
-VS_VERSION_INFO_UNICODE_SIZE
; i
++) {
1138 /* Scan for 1st 3 unicoded bytes followed by word aligned magic value */
1139 if (buf
[i
] == 'V' && buf
[i
+1] == '\0' && buf
[i
+2] == 'S') {
1140 /* Align to next long address */
1141 int pos
= (i
+ sizeof(VS_SIGNATURE
)*2 + 3) & 0xfffffffc;
1143 if (IVAL(buf
,pos
) == VS_MAGIC_VALUE
) {
1144 *major
= IVAL(buf
,pos
+VS_MAJOR_OFFSET
);
1145 *minor
= IVAL(buf
,pos
+VS_MINOR_OFFSET
);
1147 DEBUG(6,("get_file_version: PE file [%s] Version = %08x:%08x (%d.%d.%d.%d)\n",
1148 fname
, *major
, *minor
,
1149 (*major
>>16)&0xffff, *major
&0xffff,
1150 (*minor
>>16)&0xffff, *minor
&0xffff));
1159 /* Version info not found, fall back to origin date/time */
1160 DEBUG(10,("get_file_version: PE file [%s] has no version info\n", fname
));
1164 } else if (SVAL(buf
,NE_HEADER_SIGNATURE_OFFSET
) == NE_HEADER_SIGNATURE
) {
1165 if (CVAL(buf
,NE_HEADER_TARGET_OS_OFFSET
) != NE_HEADER_TARGOS_WIN
) {
1166 DEBUG(3,("get_file_version: NE file [%s] wrong target OS = 0x%x\n",
1167 fname
, CVAL(buf
,NE_HEADER_TARGET_OS_OFFSET
)));
1168 /* At this point, we assume the file is in error. It still could be somthing
1169 * else besides a NE file, but it unlikely at this point. */
1173 /* Allocate a bit more space to speed up things */
1175 if ((buf
=SMB_MALLOC(VS_NE_BUF_SIZE
)) == NULL
) {
1176 DEBUG(0,("get_file_version: NE file [%s] malloc failed bytes = %d\n",
1177 fname
, PE_HEADER_SIZE
));
1181 /* This is a HACK! I got tired of trying to sort through the messy
1182 * 'NE' file format. If anyone wants to clean this up please have at
1183 * it, but this works. 'NE' files will eventually fade away. JRR */
1184 while((byte_count
= vfs_read_data(fsp
, buf
, VS_NE_BUF_SIZE
)) > 0) {
1185 /* Cover case that should not occur in a well formed 'NE' .dll file */
1186 if (byte_count
-VS_VERSION_INFO_SIZE
<= 0) break;
1188 for(i
=0; i
<byte_count
; i
++) {
1189 /* Fast skip past data that can't possibly match */
1190 if (buf
[i
] != 'V') continue;
1192 /* Potential match data crosses buf boundry, move it to beginning
1193 * of buf, and fill the buf with as much as it will hold. */
1194 if (i
>byte_count
-VS_VERSION_INFO_SIZE
) {
1197 memcpy(buf
, &buf
[i
], byte_count
-i
);
1198 if ((bc
= vfs_read_data(fsp
, &buf
[byte_count
-i
], VS_NE_BUF_SIZE
-
1199 (byte_count
-i
))) < 0) {
1201 DEBUG(0,("get_file_version: NE file [%s] Read error, errno=%d\n",
1206 byte_count
= bc
+ (byte_count
- i
);
1207 if (byte_count
<VS_VERSION_INFO_SIZE
) break;
1212 /* Check that the full signature string and the magic number that
1213 * follows exist (not a perfect solution, but the chances that this
1214 * occurs in code is, well, remote. Yes I know I'm comparing the 'V'
1215 * twice, as it is simpler to read the code. */
1216 if (strcmp(&buf
[i
], VS_SIGNATURE
) == 0) {
1217 /* Compute skip alignment to next long address */
1218 int skip
= -(SMB_VFS_LSEEK(fsp
, fsp
->fh
->fd
, 0, SEEK_CUR
) - (byte_count
- i
) +
1219 sizeof(VS_SIGNATURE
)) & 3;
1220 if (IVAL(buf
,i
+sizeof(VS_SIGNATURE
)+skip
) != 0xfeef04bd) continue;
1222 *major
= IVAL(buf
,i
+sizeof(VS_SIGNATURE
)+skip
+VS_MAJOR_OFFSET
);
1223 *minor
= IVAL(buf
,i
+sizeof(VS_SIGNATURE
)+skip
+VS_MINOR_OFFSET
);
1224 DEBUG(6,("get_file_version: NE file [%s] Version = %08x:%08x (%d.%d.%d.%d)\n",
1225 fname
, *major
, *minor
,
1226 (*major
>>16)&0xffff, *major
&0xffff,
1227 (*minor
>>16)&0xffff, *minor
&0xffff));
1234 /* Version info not found, fall back to origin date/time */
1235 DEBUG(0,("get_file_version: NE file [%s] Version info not found\n", fname
));
1240 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
1241 DEBUG(3,("get_file_version: File [%s] unknown file format, signature = 0x%x\n",
1242 fname
, IVAL(buf
,PE_HEADER_SIGNATURE_OFFSET
)));
1253 /****************************************************************************
1254 Drivers for Microsoft systems contain multiple files. Often, multiple drivers
1255 share one or more files. During the MS installation process files are checked
1256 to insure that only a newer version of a shared file is installed over an
1257 older version. There are several possibilities for this comparison. If there
1258 is no previous version, the new one is newer (obviously). If either file is
1259 missing the version info structure, compare the creation date (on Unix use
1260 the modification date). Otherwise chose the numerically larger version number.
1261 ****************************************************************************/
1263 static int file_version_is_newer(connection_struct
*conn
, fstring new_file
, fstring old_file
)
1265 BOOL use_version
= True
;
1270 time_t new_create_time
;
1274 time_t old_create_time
;
1276 files_struct
*fsp
= NULL
;
1278 SMB_STRUCT_STAT stat_buf
;
1281 SET_STAT_INVALID(st
);
1282 SET_STAT_INVALID(stat_buf
);
1283 new_create_time
= (time_t)0;
1284 old_create_time
= (time_t)0;
1286 /* Get file version info (if available) for previous file (if it exists) */
1287 pstrcpy(filepath
, old_file
);
1289 driver_unix_convert(filepath
,conn
,NULL
,&bad_path
,&stat_buf
);
1291 fsp
= open_file_ntcreate(conn
, filepath
, &stat_buf
,
1293 FILE_SHARE_READ
|FILE_SHARE_WRITE
,
1296 FILE_ATTRIBUTE_NORMAL
,
1301 /* Old file not found, so by definition new file is in fact newer */
1302 DEBUG(10,("file_version_is_newer: Can't open old file [%s], errno = %d\n",
1307 int ret
= get_file_version(fsp
, old_file
, &old_major
, &old_minor
);
1313 DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
1315 use_version
= False
;
1316 if (SMB_VFS_FSTAT(fsp
, fsp
->fh
->fd
, &st
) == -1) goto error_exit
;
1317 old_create_time
= st
.st_mtime
;
1318 DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n", old_create_time
));
1321 close_file(fsp
, NORMAL_CLOSE
);
1323 /* Get file version info (if available) for new file */
1324 pstrcpy(filepath
, new_file
);
1325 driver_unix_convert(filepath
,conn
,NULL
,&bad_path
,&stat_buf
);
1327 fsp
= open_file_ntcreate(conn
, filepath
, &stat_buf
,
1329 FILE_SHARE_READ
|FILE_SHARE_WRITE
,
1332 FILE_ATTRIBUTE_NORMAL
,
1337 /* New file not found, this shouldn't occur if the caller did its job */
1338 DEBUG(3,("file_version_is_newer: Can't open new file [%s], errno = %d\n",
1343 int ret
= get_file_version(fsp
, new_file
, &new_major
, &new_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
, fsp
->fh
->fd
, &st
) == -1) goto error_exit
;
1353 new_create_time
= st
.st_mtime
;
1354 DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n", new_create_time
));
1357 close_file(fsp
, NORMAL_CLOSE
);
1359 if (use_version
&& (new_major
!= old_major
|| new_minor
!= old_minor
)) {
1360 /* Compare versions and choose the larger version number */
1361 if (new_major
> old_major
||
1362 (new_major
== old_major
&& new_minor
> old_minor
)) {
1364 DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file
, new_file
));
1368 DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file
));
1373 /* Compare modification time/dates and choose the newest time/date */
1374 if (new_create_time
> old_create_time
) {
1375 DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file
, new_file
));
1379 DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file
));
1386 close_file(fsp
, NORMAL_CLOSE
);
1390 /****************************************************************************
1391 Determine the correct cVersion associated with an architecture and driver
1392 ****************************************************************************/
1393 static uint32
get_correct_cversion(const char *architecture
, fstring driverpath_in
,
1394 struct current_user
*user
, WERROR
*perr
)
1401 files_struct
*fsp
= NULL
;
1404 connection_struct
*conn
;
1406 SET_STAT_INVALID(st
);
1408 *perr
= WERR_INVALID_PARAM
;
1410 /* If architecture is Windows 95/98/ME, the version is always 0. */
1411 if (strcmp(architecture
, SPL_ARCH_WIN40
) == 0) {
1412 DEBUG(10,("get_correct_cversion: Driver is Win9x, cversion = 0\n"));
1417 /* If architecture is Windows x64, the version is always 3. */
1418 if (strcmp(architecture
, SPL_ARCH_X64
) == 0) {
1419 DEBUG(10,("get_correct_cversion: Driver is x64, cversion = 3\n"));
1425 * Connect to the print$ share under the same account as the user connected
1426 * to the rpc pipe. Note we must still be root to do this.
1429 /* Null password is ok - we are already an authenticated user... */
1430 null_pw
= data_blob(NULL
, 0);
1431 fstrcpy(res_type
, "A:");
1433 conn
= make_connection_with_chdir("print$", null_pw
, res_type
, user
->vuid
, &nt_status
);
1437 DEBUG(0,("get_correct_cversion: Unable to connect\n"));
1438 *perr
= ntstatus_to_werror(nt_status
);
1442 /* We are temporarily becoming the connection user. */
1443 if (!become_user(conn
, user
->vuid
)) {
1444 DEBUG(0,("get_correct_cversion: Can't become user!\n"));
1445 *perr
= WERR_ACCESS_DENIED
;
1449 /* Open the driver file (Portable Executable format) and determine the
1450 * deriver the cversion. */
1451 slprintf(driverpath
, sizeof(driverpath
)-1, "%s/%s", architecture
, driverpath_in
);
1453 driver_unix_convert(driverpath
,conn
,NULL
,&bad_path
,&st
);
1455 if ( !vfs_file_exist( conn
, driverpath
, &st
) ) {
1456 *perr
= WERR_BADFILE
;
1460 fsp
= open_file_ntcreate(conn
, driverpath
, &st
,
1462 FILE_SHARE_READ
|FILE_SHARE_WRITE
,
1465 FILE_ATTRIBUTE_NORMAL
,
1470 DEBUG(3,("get_correct_cversion: Can't open file [%s], errno = %d\n",
1471 driverpath
, errno
));
1472 *perr
= WERR_ACCESS_DENIED
;
1477 int ret
= get_file_version(fsp
, driverpath
, &major
, &minor
);
1478 if (ret
== -1) goto error_exit
;
1481 DEBUG(6,("get_correct_cversion: Version info not found [%s]\n", driverpath
));
1486 * This is a Microsoft'ism. See references in MSDN to VER_FILEVERSION
1487 * for more details. Version in this case is not just the version of the
1488 * file, but the version in the sense of kernal mode (2) vs. user mode
1489 * (3) drivers. Other bits of the version fields are the version info.
1492 cversion
= major
& 0x0000ffff;
1494 case 2: /* WinNT drivers */
1495 case 3: /* Win2K drivers */
1499 DEBUG(6,("get_correct_cversion: cversion invalid [%s] cversion = %d\n",
1500 driverpath
, cversion
));
1504 DEBUG(10,("get_correct_cversion: Version info found [%s] major = 0x%x minor = 0x%x\n",
1505 driverpath
, major
, minor
));
1508 DEBUG(10,("get_correct_cversion: Driver file [%s] cversion = %d\n",
1509 driverpath
, cversion
));
1511 close_file(fsp
, NORMAL_CLOSE
);
1512 close_cnum(conn
, user
->vuid
);
1521 close_file(fsp
, NORMAL_CLOSE
);
1523 close_cnum(conn
, user
->vuid
);
1528 /****************************************************************************
1529 ****************************************************************************/
1530 static WERROR
clean_up_driver_struct_level_3(NT_PRINTER_DRIVER_INFO_LEVEL_3
*driver
,
1531 struct current_user
*user
)
1533 const char *architecture
;
1539 /* clean up the driver name.
1540 * we can get .\driver.dll
1541 * or worse c:\windows\system\driver.dll !
1543 /* using an intermediate string to not have overlaping memcpy()'s */
1544 if ((p
= strrchr(driver
->driverpath
,'\\')) != NULL
) {
1545 fstrcpy(new_name
, p
+1);
1546 fstrcpy(driver
->driverpath
, new_name
);
1549 if ((p
= strrchr(driver
->datafile
,'\\')) != NULL
) {
1550 fstrcpy(new_name
, p
+1);
1551 fstrcpy(driver
->datafile
, new_name
);
1554 if ((p
= strrchr(driver
->configfile
,'\\')) != NULL
) {
1555 fstrcpy(new_name
, p
+1);
1556 fstrcpy(driver
->configfile
, new_name
);
1559 if ((p
= strrchr(driver
->helpfile
,'\\')) != NULL
) {
1560 fstrcpy(new_name
, p
+1);
1561 fstrcpy(driver
->helpfile
, new_name
);
1564 if (driver
->dependentfiles
) {
1565 for (i
=0; *driver
->dependentfiles
[i
]; i
++) {
1566 if ((p
= strrchr(driver
->dependentfiles
[i
],'\\')) != NULL
) {
1567 fstrcpy(new_name
, p
+1);
1568 fstrcpy(driver
->dependentfiles
[i
], new_name
);
1573 architecture
= get_short_archi(driver
->environment
);
1574 if (!architecture
) {
1575 return WERR_UNKNOWN_PRINTER_DRIVER
;
1578 /* jfm:7/16/2000 the client always sends the cversion=0.
1579 * The server should check which version the driver is by reading
1580 * the PE header of driver->driverpath.
1582 * For Windows 95/98 the version is 0 (so the value sent is correct)
1583 * For Windows NT (the architecture doesn't matter)
1584 * NT 3.1: cversion=0
1585 * NT 3.5/3.51: cversion=1
1589 if ((driver
->cversion
= get_correct_cversion( architecture
, driver
->driverpath
, user
, &err
)) == -1)
1595 /****************************************************************************
1596 ****************************************************************************/
1597 static WERROR
clean_up_driver_struct_level_6(NT_PRINTER_DRIVER_INFO_LEVEL_6
*driver
, struct current_user
*user
)
1599 const char *architecture
;
1605 /* clean up the driver name.
1606 * we can get .\driver.dll
1607 * or worse c:\windows\system\driver.dll !
1609 /* using an intermediate string to not have overlaping memcpy()'s */
1610 if ((p
= strrchr(driver
->driverpath
,'\\')) != NULL
) {
1611 fstrcpy(new_name
, p
+1);
1612 fstrcpy(driver
->driverpath
, new_name
);
1615 if ((p
= strrchr(driver
->datafile
,'\\')) != NULL
) {
1616 fstrcpy(new_name
, p
+1);
1617 fstrcpy(driver
->datafile
, new_name
);
1620 if ((p
= strrchr(driver
->configfile
,'\\')) != NULL
) {
1621 fstrcpy(new_name
, p
+1);
1622 fstrcpy(driver
->configfile
, new_name
);
1625 if ((p
= strrchr(driver
->helpfile
,'\\')) != NULL
) {
1626 fstrcpy(new_name
, p
+1);
1627 fstrcpy(driver
->helpfile
, new_name
);
1630 if (driver
->dependentfiles
) {
1631 for (i
=0; *driver
->dependentfiles
[i
]; i
++) {
1632 if ((p
= strrchr(driver
->dependentfiles
[i
],'\\')) != NULL
) {
1633 fstrcpy(new_name
, p
+1);
1634 fstrcpy(driver
->dependentfiles
[i
], new_name
);
1639 architecture
= get_short_archi(driver
->environment
);
1640 if (!architecture
) {
1641 return WERR_UNKNOWN_PRINTER_DRIVER
;
1644 /* jfm:7/16/2000 the client always sends the cversion=0.
1645 * The server should check which version the driver is by reading
1646 * the PE header of driver->driverpath.
1648 * For Windows 95/98 the version is 0 (so the value sent is correct)
1649 * For Windows NT (the architecture doesn't matter)
1650 * NT 3.1: cversion=0
1651 * NT 3.5/3.51: cversion=1
1656 if ((driver
->version
= get_correct_cversion(architecture
, driver
->driverpath
, user
, &err
)) == -1)
1662 /****************************************************************************
1663 ****************************************************************************/
1664 WERROR
clean_up_driver_struct(NT_PRINTER_DRIVER_INFO_LEVEL driver_abstract
,
1665 uint32 level
, struct current_user
*user
)
1670 NT_PRINTER_DRIVER_INFO_LEVEL_3
*driver
;
1671 driver
=driver_abstract
.info_3
;
1672 return clean_up_driver_struct_level_3(driver
, user
);
1676 NT_PRINTER_DRIVER_INFO_LEVEL_6
*driver
;
1677 driver
=driver_abstract
.info_6
;
1678 return clean_up_driver_struct_level_6(driver
, user
);
1681 return WERR_INVALID_PARAM
;
1685 /****************************************************************************
1686 This function sucks and should be replaced. JRA.
1687 ****************************************************************************/
1689 static void convert_level_6_to_level3(NT_PRINTER_DRIVER_INFO_LEVEL_3
*dst
, NT_PRINTER_DRIVER_INFO_LEVEL_6
*src
)
1691 dst
->cversion
= src
->version
;
1693 fstrcpy( dst
->name
, src
->name
);
1694 fstrcpy( dst
->environment
, src
->environment
);
1695 fstrcpy( dst
->driverpath
, src
->driverpath
);
1696 fstrcpy( dst
->datafile
, src
->datafile
);
1697 fstrcpy( dst
->configfile
, src
->configfile
);
1698 fstrcpy( dst
->helpfile
, src
->helpfile
);
1699 fstrcpy( dst
->monitorname
, src
->monitorname
);
1700 fstrcpy( dst
->defaultdatatype
, src
->defaultdatatype
);
1701 dst
->dependentfiles
= src
->dependentfiles
;
1704 #if 0 /* Debugging function */
1706 static char* ffmt(unsigned char *c
){
1708 static char ffmt_str
[17];
1710 for (i
=0; i
<16; i
++) {
1711 if ((c
[i
] < ' ') || (c
[i
] > '~'))
1722 /****************************************************************************
1723 ****************************************************************************/
1724 WERROR
move_driver_to_download_area(NT_PRINTER_DRIVER_INFO_LEVEL driver_abstract
, uint32 level
,
1725 struct current_user
*user
, WERROR
*perr
)
1727 NT_PRINTER_DRIVER_INFO_LEVEL_3
*driver
;
1728 NT_PRINTER_DRIVER_INFO_LEVEL_3 converted_driver
;
1729 const char *architecture
;
1734 connection_struct
*conn
;
1745 memset(inbuf
, '\0', sizeof(inbuf
));
1746 memset(outbuf
, '\0', sizeof(outbuf
));
1750 driver
=driver_abstract
.info_3
;
1751 else if (level
==6) {
1752 convert_level_6_to_level3(&converted_driver
, driver_abstract
.info_6
);
1753 driver
= &converted_driver
;
1755 DEBUG(0,("move_driver_to_download_area: Unknown info level (%u)\n", (unsigned int)level
));
1756 return WERR_UNKNOWN_LEVEL
;
1759 architecture
= get_short_archi(driver
->environment
);
1760 if (!architecture
) {
1761 return WERR_UNKNOWN_PRINTER_DRIVER
;
1765 * Connect to the print$ share under the same account as the user connected to the rpc pipe.
1766 * Note we must be root to do this.
1769 null_pw
= data_blob(NULL
, 0);
1770 fstrcpy(res_type
, "A:");
1772 conn
= make_connection_with_chdir("print$", null_pw
, res_type
, user
->vuid
, &nt_status
);
1776 DEBUG(0,("move_driver_to_download_area: Unable to connect\n"));
1777 *perr
= ntstatus_to_werror(nt_status
);
1778 return WERR_NO_SUCH_SHARE
;
1782 * Save who we are - we are temporarily becoming the connection user.
1785 if (!become_user(conn
, conn
->vuid
)) {
1786 DEBUG(0,("move_driver_to_download_area: Can't become user!\n"));
1787 return WERR_ACCESS_DENIED
;
1791 * make the directories version and version\driver_name
1792 * under the architecture directory.
1794 DEBUG(5,("Creating first directory\n"));
1795 slprintf(new_dir
, sizeof(new_dir
)-1, "%s/%d", architecture
, driver
->cversion
);
1796 driver_unix_convert(new_dir
, conn
, NULL
, &bad_path
, &st
);
1797 mkdir_internal(conn
, new_dir
, bad_path
);
1799 /* For each driver file, archi\filexxx.yyy, if there is a duplicate file
1800 * listed for this driver which has already been moved, skip it (note:
1801 * drivers may list the same file name several times. Then check if the
1802 * file already exists in archi\cversion\, if so, check that the version
1803 * info (or time stamps if version info is unavailable) is newer (or the
1804 * date is later). If it is, move it to archi\cversion\filexxx.yyy.
1805 * Otherwise, delete the file.
1807 * If a file is not moved to archi\cversion\ because of an error, all the
1808 * rest of the 'unmoved' driver files are removed from archi\. If one or
1809 * more of the driver's files was already moved to archi\cversion\, it
1810 * potentially leaves the driver in a partially updated state. Version
1811 * trauma will most likely occur if an client attempts to use any printer
1812 * bound to the driver. Perhaps a rewrite to make sure the moves can be
1813 * done is appropriate... later JRR
1816 DEBUG(5,("Moving files now !\n"));
1818 if (driver
->driverpath
&& strlen(driver
->driverpath
)) {
1819 slprintf(new_name
, sizeof(new_name
)-1, "%s/%s", architecture
, driver
->driverpath
);
1820 slprintf(old_name
, sizeof(old_name
)-1, "%s/%s", new_dir
, driver
->driverpath
);
1821 if (ver
!= -1 && (ver
=file_version_is_newer(conn
, new_name
, old_name
)) > 0) {
1822 driver_unix_convert(new_name
, conn
, NULL
, &bad_path
, &st
);
1823 if ( !copy_file(new_name
, old_name
, conn
, OPENX_FILE_EXISTS_TRUNCATE
|
1824 OPENX_FILE_CREATE_IF_NOT_EXIST
, 0, False
, &err
) ) {
1825 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1826 new_name
, old_name
));
1827 *perr
= WERR_ACCESS_DENIED
;
1833 if (driver
->datafile
&& strlen(driver
->datafile
)) {
1834 if (!strequal(driver
->datafile
, driver
->driverpath
)) {
1835 slprintf(new_name
, sizeof(new_name
)-1, "%s/%s", architecture
, driver
->datafile
);
1836 slprintf(old_name
, sizeof(old_name
)-1, "%s/%s", new_dir
, driver
->datafile
);
1837 if (ver
!= -1 && (ver
=file_version_is_newer(conn
, new_name
, old_name
)) > 0) {
1838 driver_unix_convert(new_name
, conn
, NULL
, &bad_path
, &st
);
1839 if ( !copy_file(new_name
, old_name
, conn
, OPENX_FILE_EXISTS_TRUNCATE
|
1840 OPENX_FILE_CREATE_IF_NOT_EXIST
, 0, False
, &err
) ) {
1841 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1842 new_name
, old_name
));
1843 *perr
= WERR_ACCESS_DENIED
;
1850 if (driver
->configfile
&& strlen(driver
->configfile
)) {
1851 if (!strequal(driver
->configfile
, driver
->driverpath
) &&
1852 !strequal(driver
->configfile
, driver
->datafile
)) {
1853 slprintf(new_name
, sizeof(new_name
)-1, "%s/%s", architecture
, driver
->configfile
);
1854 slprintf(old_name
, sizeof(old_name
)-1, "%s/%s", new_dir
, driver
->configfile
);
1855 if (ver
!= -1 && (ver
=file_version_is_newer(conn
, new_name
, old_name
)) > 0) {
1856 driver_unix_convert(new_name
, conn
, NULL
, &bad_path
, &st
);
1857 if ( !copy_file(new_name
, old_name
, conn
, OPENX_FILE_EXISTS_TRUNCATE
|
1858 OPENX_FILE_CREATE_IF_NOT_EXIST
, 0, False
, &err
) ) {
1859 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1860 new_name
, old_name
));
1861 *perr
= WERR_ACCESS_DENIED
;
1868 if (driver
->helpfile
&& strlen(driver
->helpfile
)) {
1869 if (!strequal(driver
->helpfile
, driver
->driverpath
) &&
1870 !strequal(driver
->helpfile
, driver
->datafile
) &&
1871 !strequal(driver
->helpfile
, driver
->configfile
)) {
1872 slprintf(new_name
, sizeof(new_name
)-1, "%s/%s", architecture
, driver
->helpfile
);
1873 slprintf(old_name
, sizeof(old_name
)-1, "%s/%s", new_dir
, driver
->helpfile
);
1874 if (ver
!= -1 && (ver
=file_version_is_newer(conn
, new_name
, old_name
)) > 0) {
1875 driver_unix_convert(new_name
, conn
, NULL
, &bad_path
, &st
);
1876 if ( !copy_file(new_name
, old_name
, conn
, OPENX_FILE_EXISTS_TRUNCATE
|
1877 OPENX_FILE_CREATE_IF_NOT_EXIST
, 0, False
, &err
) ) {
1878 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1879 new_name
, old_name
));
1880 *perr
= WERR_ACCESS_DENIED
;
1887 if (driver
->dependentfiles
) {
1888 for (i
=0; *driver
->dependentfiles
[i
]; i
++) {
1889 if (!strequal(driver
->dependentfiles
[i
], driver
->driverpath
) &&
1890 !strequal(driver
->dependentfiles
[i
], driver
->datafile
) &&
1891 !strequal(driver
->dependentfiles
[i
], driver
->configfile
) &&
1892 !strequal(driver
->dependentfiles
[i
], driver
->helpfile
)) {
1894 for (j
=0; j
< i
; j
++) {
1895 if (strequal(driver
->dependentfiles
[i
], driver
->dependentfiles
[j
])) {
1900 slprintf(new_name
, sizeof(new_name
)-1, "%s/%s", architecture
, driver
->dependentfiles
[i
]);
1901 slprintf(old_name
, sizeof(old_name
)-1, "%s/%s", new_dir
, driver
->dependentfiles
[i
]);
1902 if (ver
!= -1 && (ver
=file_version_is_newer(conn
, new_name
, old_name
)) > 0) {
1903 driver_unix_convert(new_name
, conn
, NULL
, &bad_path
, &st
);
1904 if ( !copy_file(new_name
, old_name
, conn
,
1905 OPENX_FILE_EXISTS_TRUNCATE
|
1906 OPENX_FILE_CREATE_IF_NOT_EXIST
, 0, False
, &err
) ) {
1907 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1908 new_name
, old_name
));
1909 *perr
= WERR_ACCESS_DENIED
;
1918 close_cnum(conn
, user
->vuid
);
1921 return ver
!= -1 ? WERR_OK
: WERR_UNKNOWN_PRINTER_DRIVER
;
1924 /****************************************************************************
1925 ****************************************************************************/
1926 static uint32
add_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3
*driver
)
1929 const char *architecture
;
1935 TDB_DATA kbuf
, dbuf
;
1937 architecture
= get_short_archi(driver
->environment
);
1938 if (!architecture
) {
1942 /* The names are relative. We store them in the form: \print$\arch\version\driver.xxx
1943 * \\server is added in the rpc server layer.
1944 * It does make sense to NOT store the server's name in the printer TDB.
1947 slprintf(directory
, sizeof(directory
)-1, "\\print$\\%s\\%d\\", architecture
, driver
->cversion
);
1949 /* .inf files do not always list a file for each of the four standard files.
1950 * Don't prepend a path to a null filename, or client claims:
1951 * "The server on which the printer resides does not have a suitable
1952 * <printer driver name> printer driver installed. Click OK if you
1953 * wish to install the driver on your local machine."
1955 if (strlen(driver
->driverpath
)) {
1956 fstrcpy(temp_name
, driver
->driverpath
);
1957 slprintf(driver
->driverpath
, sizeof(driver
->driverpath
)-1, "%s%s", directory
, temp_name
);
1960 if (strlen(driver
->datafile
)) {
1961 fstrcpy(temp_name
, driver
->datafile
);
1962 slprintf(driver
->datafile
, sizeof(driver
->datafile
)-1, "%s%s", directory
, temp_name
);
1965 if (strlen(driver
->configfile
)) {
1966 fstrcpy(temp_name
, driver
->configfile
);
1967 slprintf(driver
->configfile
, sizeof(driver
->configfile
)-1, "%s%s", directory
, temp_name
);
1970 if (strlen(driver
->helpfile
)) {
1971 fstrcpy(temp_name
, driver
->helpfile
);
1972 slprintf(driver
->helpfile
, sizeof(driver
->helpfile
)-1, "%s%s", directory
, temp_name
);
1975 if (driver
->dependentfiles
) {
1976 for (i
=0; *driver
->dependentfiles
[i
]; i
++) {
1977 fstrcpy(temp_name
, driver
->dependentfiles
[i
]);
1978 slprintf(driver
->dependentfiles
[i
], sizeof(driver
->dependentfiles
[i
])-1, "%s%s", directory
, temp_name
);
1982 slprintf(key
, sizeof(key
)-1, "%s%s/%d/%s", DRIVERS_PREFIX
, architecture
, driver
->cversion
, driver
->name
);
1984 DEBUG(5,("add_a_printer_driver_3: Adding driver with key %s\n", key
));
1991 len
+= tdb_pack(buf
+len
, buflen
-len
, "dffffffff",
1994 driver
->environment
,
1999 driver
->monitorname
,
2000 driver
->defaultdatatype
);
2002 if (driver
->dependentfiles
) {
2003 for (i
=0; *driver
->dependentfiles
[i
]; i
++) {
2004 len
+= tdb_pack(buf
+len
, buflen
-len
, "f",
2005 driver
->dependentfiles
[i
]);
2009 if (len
!= buflen
) {
2010 buf
= (char *)SMB_REALLOC(buf
, len
);
2012 DEBUG(0,("add_a_printer_driver_3: failed to enlarge buffer\n!"));
2022 kbuf
.dsize
= strlen(key
)+1;
2026 ret
= tdb_store(tdb_drivers
, kbuf
, dbuf
, TDB_REPLACE
);
2030 DEBUG(0,("add_a_printer_driver_3: Adding driver with key %s failed.\n", key
));
2036 /****************************************************************************
2037 ****************************************************************************/
2038 static uint32
add_a_printer_driver_6(NT_PRINTER_DRIVER_INFO_LEVEL_6
*driver
)
2040 NT_PRINTER_DRIVER_INFO_LEVEL_3 info3
;
2043 info3
.cversion
= driver
->version
;
2044 fstrcpy(info3
.name
,driver
->name
);
2045 fstrcpy(info3
.environment
,driver
->environment
);
2046 fstrcpy(info3
.driverpath
,driver
->driverpath
);
2047 fstrcpy(info3
.datafile
,driver
->datafile
);
2048 fstrcpy(info3
.configfile
,driver
->configfile
);
2049 fstrcpy(info3
.helpfile
,driver
->helpfile
);
2050 fstrcpy(info3
.monitorname
,driver
->monitorname
);
2051 fstrcpy(info3
.defaultdatatype
,driver
->defaultdatatype
);
2052 info3
.dependentfiles
= driver
->dependentfiles
;
2054 return add_a_printer_driver_3(&info3
);
2058 /****************************************************************************
2059 ****************************************************************************/
2060 static WERROR
get_a_printer_driver_3_default(NT_PRINTER_DRIVER_INFO_LEVEL_3
**info_ptr
, const char *driver
, const char *arch
)
2062 NT_PRINTER_DRIVER_INFO_LEVEL_3 info
;
2066 fstrcpy(info
.name
, driver
);
2067 fstrcpy(info
.defaultdatatype
, "RAW");
2069 fstrcpy(info
.driverpath
, "");
2070 fstrcpy(info
.datafile
, "");
2071 fstrcpy(info
.configfile
, "");
2072 fstrcpy(info
.helpfile
, "");
2074 if ((info
.dependentfiles
= SMB_MALLOC_ARRAY(fstring
, 2)) == NULL
)
2077 memset(info
.dependentfiles
, '\0', 2*sizeof(fstring
));
2078 fstrcpy(info
.dependentfiles
[0], "");
2080 *info_ptr
= memdup(&info
, sizeof(info
));
2085 /****************************************************************************
2086 ****************************************************************************/
2087 static WERROR
get_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3
**info_ptr
, fstring drivername
, const char *arch
, uint32 version
)
2089 NT_PRINTER_DRIVER_INFO_LEVEL_3 driver
;
2090 TDB_DATA kbuf
, dbuf
;
2091 const char *architecture
;
2096 ZERO_STRUCT(driver
);
2098 architecture
= get_short_archi(arch
);
2099 if ( !architecture
) {
2100 return WERR_UNKNOWN_PRINTER_DRIVER
;
2103 /* Windows 4.0 (i.e. win9x) should always use a version of 0 */
2105 if ( strcmp( architecture
, SPL_ARCH_WIN40
) == 0 )
2108 DEBUG(8,("get_a_printer_driver_3: [%s%s/%d/%s]\n", DRIVERS_PREFIX
, architecture
, version
, drivername
));
2110 slprintf(key
, sizeof(key
)-1, "%s%s/%d/%s", DRIVERS_PREFIX
, architecture
, version
, drivername
);
2113 kbuf
.dsize
= strlen(key
)+1;
2115 dbuf
= tdb_fetch(tdb_drivers
, kbuf
);
2117 return WERR_UNKNOWN_PRINTER_DRIVER
;
2119 len
+= tdb_unpack(dbuf
.dptr
, dbuf
.dsize
, "dffffffff",
2128 driver
.defaultdatatype
);
2131 while (len
< dbuf
.dsize
) {
2132 driver
.dependentfiles
= SMB_REALLOC_ARRAY(driver
.dependentfiles
, fstring
, i
+2);
2133 if ( !driver
.dependentfiles
) {
2134 DEBUG(0,("get_a_printer_driver_3: failed to enlarge buffer!\n"));
2138 len
+= tdb_unpack(dbuf
.dptr
+len
, dbuf
.dsize
-len
, "f",
2139 &driver
.dependentfiles
[i
]);
2143 if ( driver
.dependentfiles
)
2144 fstrcpy( driver
.dependentfiles
[i
], "" );
2146 SAFE_FREE(dbuf
.dptr
);
2148 if (len
!= dbuf
.dsize
) {
2149 SAFE_FREE(driver
.dependentfiles
);
2151 return get_a_printer_driver_3_default(info_ptr
, drivername
, arch
);
2154 *info_ptr
= (NT_PRINTER_DRIVER_INFO_LEVEL_3
*)memdup(&driver
, sizeof(driver
));
2159 /****************************************************************************
2160 Debugging function, dump at level 6 the struct in the logs.
2161 ****************************************************************************/
2163 static uint32
dump_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver
, uint32 level
)
2166 NT_PRINTER_DRIVER_INFO_LEVEL_3
*info3
;
2169 DEBUG(20,("Dumping printer driver at level [%d]\n", level
));
2175 if (driver
.info_3
== NULL
)
2178 info3
=driver
.info_3
;
2180 DEBUGADD(20,("version:[%d]\n", info3
->cversion
));
2181 DEBUGADD(20,("name:[%s]\n", info3
->name
));
2182 DEBUGADD(20,("environment:[%s]\n", info3
->environment
));
2183 DEBUGADD(20,("driverpath:[%s]\n", info3
->driverpath
));
2184 DEBUGADD(20,("datafile:[%s]\n", info3
->datafile
));
2185 DEBUGADD(20,("configfile:[%s]\n", info3
->configfile
));
2186 DEBUGADD(20,("helpfile:[%s]\n", info3
->helpfile
));
2187 DEBUGADD(20,("monitorname:[%s]\n", info3
->monitorname
));
2188 DEBUGADD(20,("defaultdatatype:[%s]\n", info3
->defaultdatatype
));
2190 for (i
=0; info3
->dependentfiles
&&
2191 *info3
->dependentfiles
[i
]; i
++) {
2192 DEBUGADD(20,("dependentfile:[%s]\n",
2193 info3
->dependentfiles
[i
]));
2200 DEBUGADD(20,("dump_a_printer_driver: Level %u not implemented\n", (unsigned int)level
));
2208 /****************************************************************************
2209 ****************************************************************************/
2210 int pack_devicemode(NT_DEVICEMODE
*nt_devmode
, char *buf
, int buflen
)
2214 len
+= tdb_pack(buf
+len
, buflen
-len
, "p", nt_devmode
);
2219 len
+= tdb_pack(buf
+len
, buflen
-len
, "ffwwwwwwwwwwwwwwwwwwddddddddddddddp",
2220 nt_devmode
->devicename
,
2221 nt_devmode
->formname
,
2223 nt_devmode
->specversion
,
2224 nt_devmode
->driverversion
,
2226 nt_devmode
->driverextra
,
2227 nt_devmode
->orientation
,
2228 nt_devmode
->papersize
,
2229 nt_devmode
->paperlength
,
2230 nt_devmode
->paperwidth
,
2233 nt_devmode
->defaultsource
,
2234 nt_devmode
->printquality
,
2237 nt_devmode
->yresolution
,
2238 nt_devmode
->ttoption
,
2239 nt_devmode
->collate
,
2240 nt_devmode
->logpixels
,
2243 nt_devmode
->bitsperpel
,
2244 nt_devmode
->pelswidth
,
2245 nt_devmode
->pelsheight
,
2246 nt_devmode
->displayflags
,
2247 nt_devmode
->displayfrequency
,
2248 nt_devmode
->icmmethod
,
2249 nt_devmode
->icmintent
,
2250 nt_devmode
->mediatype
,
2251 nt_devmode
->dithertype
,
2252 nt_devmode
->reserved1
,
2253 nt_devmode
->reserved2
,
2254 nt_devmode
->panningwidth
,
2255 nt_devmode
->panningheight
,
2256 nt_devmode
->nt_dev_private
);
2259 if (nt_devmode
->nt_dev_private
) {
2260 len
+= tdb_pack(buf
+len
, buflen
-len
, "B",
2261 nt_devmode
->driverextra
,
2262 nt_devmode
->nt_dev_private
);
2265 DEBUG(8,("Packed devicemode [%s]\n", nt_devmode
->formname
));
2270 /****************************************************************************
2271 Pack all values in all printer keys
2272 ***************************************************************************/
2274 static int pack_values(NT_PRINTER_DATA
*data
, char *buf
, int buflen
)
2278 REGISTRY_VALUE
*val
;
2279 REGVAL_CTR
*val_ctr
;
2286 /* loop over all keys */
2288 for ( i
=0; i
<data
->num_keys
; i
++ ) {
2289 val_ctr
= data
->keys
[i
].values
;
2290 num_values
= regval_ctr_numvals( val_ctr
);
2292 /* pack the keyname followed by a empty value */
2294 len
+= tdb_pack(buf
+len
, buflen
-len
, "pPdB",
2295 &data
->keys
[i
].name
,
2301 /* now loop over all values */
2303 for ( j
=0; j
<num_values
; j
++ ) {
2304 /* pathname should be stored as <key>\<value> */
2306 val
= regval_ctr_specific_value( val_ctr
, j
);
2307 pstrcpy( path
, data
->keys
[i
].name
);
2308 pstrcat( path
, "\\" );
2309 pstrcat( path
, regval_name(val
) );
2311 len
+= tdb_pack(buf
+len
, buflen
-len
, "pPdB",
2316 regval_data_p(val
) );
2318 DEBUG(8,("specific: [%s], len: %d\n", regval_name(val
), regval_size(val
)));
2325 len
+= tdb_pack(buf
+len
, buflen
-len
, "p", NULL
);
2331 /****************************************************************************
2332 Delete a printer - this just deletes the printer info file, any open
2333 handles are not affected.
2334 ****************************************************************************/
2336 uint32
del_a_printer(const char *sharename
)
2339 pstring printdb_path
;
2341 kbuf
= make_printer_tdbkey( sharename
);
2342 tdb_delete(tdb_printers
, kbuf
);
2344 kbuf
.dptr
= make_printers_secdesc_tdbkey( sharename
);
2345 kbuf
.dsize
= strlen(kbuf
.dptr
) + 1;
2346 tdb_delete(tdb_printers
, kbuf
);
2348 close_all_print_db();
2350 if (geteuid() == 0) {
2351 pstrcpy(printdb_path
, lock_path("printing/"));
2352 pstrcat(printdb_path
, sharename
);
2353 pstrcat(printdb_path
, ".tdb");
2355 unlink(printdb_path
);
2361 /****************************************************************************
2362 ****************************************************************************/
2363 static WERROR
update_a_printer_2(NT_PRINTER_INFO_LEVEL_2
*info
)
2368 TDB_DATA kbuf
, dbuf
;
2371 * in addprinter: no servername and the printer is the name
2372 * in setprinter: servername is \\server
2373 * and printer is \\server\\printer
2375 * Samba manages only local printers.
2376 * we currently don't support things like i
2377 * path=\\other_server\printer
2379 * We only store the printername, not \\server\printername
2382 if ( info
->servername
[0] != '\0' ) {
2383 trim_string(info
->printername
, info
->servername
, NULL
);
2384 trim_char(info
->printername
, '\\', '\0');
2385 info
->servername
[0]='\0';
2389 * JFM: one day I'll forget.
2390 * below that's info->portname because that's the SAMBA sharename
2391 * and I made NT 'thinks' it's the portname
2392 * the info->sharename is the thing you can name when you add a printer
2393 * that's the short-name when you create shared printer for 95/98
2394 * So I've made a limitation in SAMBA: you can only have 1 printer model
2395 * behind a SAMBA share.
2403 len
+= tdb_pack(buf
+len
, buflen
-len
, "dddddddddddfffffPfffff",
2406 info
->default_priority
,
2423 info
->printprocessor
,
2427 len
+= pack_devicemode(info
->devmode
, buf
+len
, buflen
-len
);
2429 len
+= pack_values( info
->data
, buf
+len
, buflen
-len
);
2431 if (buflen
!= len
) {
2432 buf
= (char *)SMB_REALLOC(buf
, len
);
2434 DEBUG(0,("update_a_printer_2: failed to enlarge buffer!\n"));
2443 kbuf
= make_printer_tdbkey( info
->sharename
);
2448 ret
= (tdb_store(tdb_printers
, kbuf
, dbuf
, TDB_REPLACE
) == 0? WERR_OK
: WERR_NOMEM
);
2451 if (!W_ERROR_IS_OK(ret
))
2452 DEBUG(8, ("error updating printer to tdb on disk\n"));
2456 DEBUG(8,("packed printer [%s] with driver [%s] portname=[%s] len=%d\n",
2457 info
->sharename
, info
->drivername
, info
->portname
, len
));
2463 /****************************************************************************
2464 Malloc and return an NT devicemode.
2465 ****************************************************************************/
2467 NT_DEVICEMODE
*construct_nt_devicemode(const fstring default_devicename
)
2470 char adevice
[MAXDEVICENAME
];
2471 NT_DEVICEMODE
*nt_devmode
= SMB_MALLOC_P(NT_DEVICEMODE
);
2473 if (nt_devmode
== NULL
) {
2474 DEBUG(0,("construct_nt_devicemode: malloc fail.\n"));
2478 ZERO_STRUCTP(nt_devmode
);
2480 slprintf(adevice
, sizeof(adevice
), "%s", default_devicename
);
2481 fstrcpy(nt_devmode
->devicename
, adevice
);
2483 fstrcpy(nt_devmode
->formname
, "Letter");
2485 nt_devmode
->specversion
= 0x0401;
2486 nt_devmode
->driverversion
= 0x0400;
2487 nt_devmode
->size
= 0x00DC;
2488 nt_devmode
->driverextra
= 0x0000;
2489 nt_devmode
->fields
= FORMNAME
| TTOPTION
| PRINTQUALITY
|
2490 DEFAULTSOURCE
| COPIES
| SCALE
|
2491 PAPERSIZE
| ORIENTATION
;
2492 nt_devmode
->orientation
= 1;
2493 nt_devmode
->papersize
= PAPER_LETTER
;
2494 nt_devmode
->paperlength
= 0;
2495 nt_devmode
->paperwidth
= 0;
2496 nt_devmode
->scale
= 0x64;
2497 nt_devmode
->copies
= 1;
2498 nt_devmode
->defaultsource
= BIN_FORMSOURCE
;
2499 nt_devmode
->printquality
= RES_HIGH
; /* 0x0258 */
2500 nt_devmode
->color
= COLOR_MONOCHROME
;
2501 nt_devmode
->duplex
= DUP_SIMPLEX
;
2502 nt_devmode
->yresolution
= 0;
2503 nt_devmode
->ttoption
= TT_SUBDEV
;
2504 nt_devmode
->collate
= COLLATE_FALSE
;
2505 nt_devmode
->icmmethod
= 0;
2506 nt_devmode
->icmintent
= 0;
2507 nt_devmode
->mediatype
= 0;
2508 nt_devmode
->dithertype
= 0;
2510 /* non utilisés par un driver d'imprimante */
2511 nt_devmode
->logpixels
= 0;
2512 nt_devmode
->bitsperpel
= 0;
2513 nt_devmode
->pelswidth
= 0;
2514 nt_devmode
->pelsheight
= 0;
2515 nt_devmode
->displayflags
= 0;
2516 nt_devmode
->displayfrequency
= 0;
2517 nt_devmode
->reserved1
= 0;
2518 nt_devmode
->reserved2
= 0;
2519 nt_devmode
->panningwidth
= 0;
2520 nt_devmode
->panningheight
= 0;
2522 nt_devmode
->nt_dev_private
= NULL
;
2526 /****************************************************************************
2527 Deepcopy an NT devicemode.
2528 ****************************************************************************/
2530 NT_DEVICEMODE
*dup_nt_devicemode(NT_DEVICEMODE
*nt_devicemode
)
2532 NT_DEVICEMODE
*new_nt_devicemode
= NULL
;
2534 if ( !nt_devicemode
)
2537 if ((new_nt_devicemode
= (NT_DEVICEMODE
*)memdup(nt_devicemode
, sizeof(NT_DEVICEMODE
))) == NULL
) {
2538 DEBUG(0,("dup_nt_devicemode: malloc fail.\n"));
2542 new_nt_devicemode
->nt_dev_private
= NULL
;
2543 if (nt_devicemode
->nt_dev_private
!= NULL
) {
2544 if ((new_nt_devicemode
->nt_dev_private
= memdup(nt_devicemode
->nt_dev_private
, nt_devicemode
->driverextra
)) == NULL
) {
2545 SAFE_FREE(new_nt_devicemode
);
2546 DEBUG(0,("dup_nt_devicemode: malloc fail.\n"));
2551 return new_nt_devicemode
;
2554 /****************************************************************************
2555 Clean up and deallocate a (maybe partially) allocated NT_DEVICEMODE.
2556 ****************************************************************************/
2558 void free_nt_devicemode(NT_DEVICEMODE
**devmode_ptr
)
2560 NT_DEVICEMODE
*nt_devmode
= *devmode_ptr
;
2562 if(nt_devmode
== NULL
)
2565 DEBUG(106,("free_nt_devicemode: deleting DEVMODE\n"));
2567 SAFE_FREE(nt_devmode
->nt_dev_private
);
2568 SAFE_FREE(*devmode_ptr
);
2571 /****************************************************************************
2572 Clean up and deallocate a (maybe partially) allocated NT_PRINTER_INFO_LEVEL_2.
2573 ****************************************************************************/
2575 static void free_nt_printer_info_level_2(NT_PRINTER_INFO_LEVEL_2
**info_ptr
)
2577 NT_PRINTER_INFO_LEVEL_2
*info
= *info_ptr
;
2582 free_nt_devicemode(&info
->devmode
);
2584 TALLOC_FREE( *info_ptr
);
2588 /****************************************************************************
2589 ****************************************************************************/
2590 int unpack_devicemode(NT_DEVICEMODE
**nt_devmode
, char *buf
, int buflen
)
2594 NT_DEVICEMODE devmode
;
2596 ZERO_STRUCT(devmode
);
2598 len
+= tdb_unpack(buf
+len
, buflen
-len
, "p", nt_devmode
);
2600 if (!*nt_devmode
) return len
;
2602 len
+= tdb_unpack(buf
+len
, buflen
-len
, "ffwwwwwwwwwwwwwwwwwwddddddddddddddp",
2606 &devmode
.specversion
,
2607 &devmode
.driverversion
,
2609 &devmode
.driverextra
,
2610 &devmode
.orientation
,
2612 &devmode
.paperlength
,
2613 &devmode
.paperwidth
,
2616 &devmode
.defaultsource
,
2617 &devmode
.printquality
,
2620 &devmode
.yresolution
,
2626 &devmode
.bitsperpel
,
2628 &devmode
.pelsheight
,
2629 &devmode
.displayflags
,
2630 &devmode
.displayfrequency
,
2634 &devmode
.dithertype
,
2637 &devmode
.panningwidth
,
2638 &devmode
.panningheight
,
2639 &devmode
.nt_dev_private
);
2641 if (devmode
.nt_dev_private
) {
2642 /* the len in tdb_unpack is an int value and
2643 * devmode.driverextra is only a short
2645 len
+= tdb_unpack(buf
+len
, buflen
-len
, "B", &extra_len
, &devmode
.nt_dev_private
);
2646 devmode
.driverextra
=(uint16
)extra_len
;
2648 /* check to catch an invalid TDB entry so we don't segfault */
2649 if (devmode
.driverextra
== 0) {
2650 devmode
.nt_dev_private
= NULL
;
2654 *nt_devmode
= (NT_DEVICEMODE
*)memdup(&devmode
, sizeof(devmode
));
2656 DEBUG(8,("Unpacked devicemode [%s](%s)\n", devmode
.devicename
, devmode
.formname
));
2657 if (devmode
.nt_dev_private
)
2658 DEBUG(8,("with a private section of %d bytes\n", devmode
.driverextra
));
2663 /****************************************************************************
2664 Allocate and initialize a new slot.
2665 ***************************************************************************/
2667 int add_new_printer_key( NT_PRINTER_DATA
*data
, const char *name
)
2672 if ( !name
|| !data
)
2675 /* allocate another slot in the NT_PRINTER_KEY array */
2677 if ( !(d
= TALLOC_REALLOC_ARRAY( data
, data
->keys
, NT_PRINTER_KEY
, data
->num_keys
+1)) ) {
2678 DEBUG(0,("add_new_printer_key: Realloc() failed!\n"));
2684 key_index
= data
->num_keys
;
2686 /* initialze new key */
2688 data
->keys
[key_index
].name
= talloc_strdup( data
, name
);
2690 if ( !(data
->keys
[key_index
].values
= TALLOC_ZERO_P( data
, REGVAL_CTR
)) )
2695 DEBUG(10,("add_new_printer_key: Inserted new data key [%s]\n", name
));
2700 /****************************************************************************
2701 search for a registry key name in the existing printer data
2702 ***************************************************************************/
2704 int delete_printer_key( NT_PRINTER_DATA
*data
, const char *name
)
2708 for ( i
=0; i
<data
->num_keys
; i
++ ) {
2709 if ( strequal( data
->keys
[i
].name
, name
) ) {
2711 /* cleanup memory */
2713 TALLOC_FREE( data
->keys
[i
].name
);
2714 TALLOC_FREE( data
->keys
[i
].values
);
2716 /* if not the end of the array, move remaining elements down one slot */
2719 if ( data
->num_keys
&& (i
< data
->num_keys
) )
2720 memmove( &data
->keys
[i
], &data
->keys
[i
+1], sizeof(NT_PRINTER_KEY
)*(data
->num_keys
-i
) );
2727 return data
->num_keys
;
2730 /****************************************************************************
2731 search for a registry key name in the existing printer data
2732 ***************************************************************************/
2734 int lookup_printerkey( NT_PRINTER_DATA
*data
, const char *name
)
2739 if ( !data
|| !name
)
2742 DEBUG(12,("lookup_printerkey: Looking for [%s]\n", name
));
2744 /* loop over all existing keys */
2746 for ( i
=0; i
<data
->num_keys
; i
++ ) {
2747 if ( strequal(data
->keys
[i
].name
, name
) ) {
2748 DEBUG(12,("lookup_printerkey: Found [%s]!\n", name
));
2758 /****************************************************************************
2759 ***************************************************************************/
2761 int get_printer_subkeys( NT_PRINTER_DATA
*data
, const char* key
, fstring
**subkeys
)
2765 int num_subkeys
= 0;
2767 fstring
*subkeys_ptr
= NULL
;
2778 /* special case of asking for the top level printer data registry key names */
2780 if ( strlen(key
) == 0 ) {
2781 for ( i
=0; i
<data
->num_keys
; i
++ ) {
2783 /* found a match, so allocate space and copy the name */
2785 if ( !(subkeys_ptr
= SMB_REALLOC_ARRAY( subkeys_ptr
, fstring
, num_subkeys
+2)) ) {
2786 DEBUG(0,("get_printer_subkeys: Realloc failed for [%d] entries!\n",
2791 fstrcpy( subkeys_ptr
[num_subkeys
], data
->keys
[i
].name
);
2798 /* asking for the subkeys of some key */
2799 /* subkey paths are stored in the key name using '\' as the delimiter */
2801 for ( i
=0; i
<data
->num_keys
; i
++ ) {
2802 if ( StrnCaseCmp(data
->keys
[i
].name
, key
, strlen(key
)) == 0 ) {
2804 /* if we found the exact key, then break */
2805 key_len
= strlen( key
);
2806 if ( strlen(data
->keys
[i
].name
) == key_len
)
2809 /* get subkey path */
2811 p
= data
->keys
[i
].name
+ key_len
;
2814 fstrcpy( subkeyname
, p
);
2815 if ( (p
= strchr( subkeyname
, '\\' )) )
2818 /* don't add a key more than once */
2820 for ( j
=0; j
<num_subkeys
; j
++ ) {
2821 if ( strequal( subkeys_ptr
[j
], subkeyname
) )
2825 if ( j
!= num_subkeys
)
2828 /* found a match, so allocate space and copy the name */
2830 if ( !(subkeys_ptr
= SMB_REALLOC_ARRAY( subkeys_ptr
, fstring
, num_subkeys
+2)) ) {
2831 DEBUG(0,("get_printer_subkeys: Realloc failed for [%d] entries!\n",
2836 fstrcpy( subkeys_ptr
[num_subkeys
], subkeyname
);
2842 /* return error if the key was not found */
2844 if ( i
== data
->num_keys
) {
2845 SAFE_FREE(subkeys_ptr
);
2850 /* tag off the end */
2853 fstrcpy(subkeys_ptr
[num_subkeys
], "" );
2855 *subkeys
= subkeys_ptr
;
2861 static void map_sz_into_ctr(REGVAL_CTR
*ctr
, const char *val_name
,
2864 smb_ucs2_t conv_str
[1024];
2867 regval_ctr_delvalue(ctr
, val_name
);
2868 str_size
= push_ucs2(NULL
, conv_str
, sz
, sizeof(conv_str
),
2869 STR_TERMINATE
| STR_NOALIGN
);
2870 regval_ctr_addvalue(ctr
, val_name
, REG_SZ
,
2871 (char *) conv_str
, str_size
);
2874 static void map_dword_into_ctr(REGVAL_CTR
*ctr
, const char *val_name
,
2877 regval_ctr_delvalue(ctr
, val_name
);
2878 regval_ctr_addvalue(ctr
, val_name
, REG_DWORD
,
2879 (char *) &dword
, sizeof(dword
));
2882 static void map_bool_into_ctr(REGVAL_CTR
*ctr
, const char *val_name
,
2885 uint8 bin_bool
= (b
? 1 : 0);
2886 regval_ctr_delvalue(ctr
, val_name
);
2887 regval_ctr_addvalue(ctr
, val_name
, REG_BINARY
,
2888 (char *) &bin_bool
, sizeof(bin_bool
));
2891 static void map_single_multi_sz_into_ctr(REGVAL_CTR
*ctr
, const char *val_name
,
2892 const char *multi_sz
)
2894 smb_ucs2_t
*conv_strs
= NULL
;
2897 /* a multi-sz has to have a null string terminator, i.e., the last
2898 string must be followed by two nulls */
2899 str_size
= strlen(multi_sz
) + 2;
2900 conv_strs
= SMB_CALLOC_ARRAY(smb_ucs2_t
, str_size
);
2905 /* Change to byte units. */
2906 str_size
*= sizeof(smb_ucs2_t
);
2907 push_ucs2(NULL
, conv_strs
, multi_sz
, str_size
,
2908 STR_TERMINATE
| STR_NOALIGN
);
2910 regval_ctr_delvalue(ctr
, val_name
);
2911 regval_ctr_addvalue(ctr
, val_name
, REG_MULTI_SZ
,
2912 (char *) conv_strs
, str_size
);
2913 safe_free(conv_strs
);
2917 /****************************************************************************
2918 * Map the NT_PRINTER_INFO_LEVEL_2 data into DsSpooler keys for publishing.
2920 * @param info2 NT_PRINTER_INFO_LEVEL_2 describing printer - gets modified
2921 * @return BOOL indicating success or failure
2922 ***************************************************************************/
2924 static BOOL
map_nt_printer_info2_to_dsspooler(NT_PRINTER_INFO_LEVEL_2
*info2
)
2926 REGVAL_CTR
*ctr
= NULL
;
2929 char *allocated_string
= NULL
;
2930 const char *ascii_str
;
2933 if ((i
= lookup_printerkey(info2
->data
, SPOOL_DSSPOOLER_KEY
)) < 0)
2934 i
= add_new_printer_key(info2
->data
, SPOOL_DSSPOOLER_KEY
);
2935 ctr
= info2
->data
->keys
[i
].values
;
2937 map_sz_into_ctr(ctr
, SPOOL_REG_PRINTERNAME
, info2
->sharename
);
2938 map_sz_into_ctr(ctr
, SPOOL_REG_SHORTSERVERNAME
, global_myname());
2940 /* we make the assumption that the netbios name is the same
2941 as the DNS name sinc ethe former will be what we used to
2944 if ( get_mydnsdomname( dnssuffix
) )
2945 fstr_sprintf( longname
, "%s.%s", global_myname(), dnssuffix
);
2947 fstrcpy( longname
, global_myname() );
2949 map_sz_into_ctr(ctr
, SPOOL_REG_SERVERNAME
, longname
);
2951 asprintf(&allocated_string
, "\\\\%s\\%s", longname
, info2
->sharename
);
2952 map_sz_into_ctr(ctr
, SPOOL_REG_UNCNAME
, allocated_string
);
2953 SAFE_FREE(allocated_string
);
2955 map_dword_into_ctr(ctr
, SPOOL_REG_VERSIONNUMBER
, 4);
2956 map_sz_into_ctr(ctr
, SPOOL_REG_DRIVERNAME
, info2
->drivername
);
2957 map_sz_into_ctr(ctr
, SPOOL_REG_LOCATION
, info2
->location
);
2958 map_sz_into_ctr(ctr
, SPOOL_REG_DESCRIPTION
, info2
->comment
);
2959 map_single_multi_sz_into_ctr(ctr
, SPOOL_REG_PORTNAME
, info2
->portname
);
2960 map_sz_into_ctr(ctr
, SPOOL_REG_PRINTSEPARATORFILE
, info2
->sepfile
);
2961 map_dword_into_ctr(ctr
, SPOOL_REG_PRINTSTARTTIME
, info2
->starttime
);
2962 map_dword_into_ctr(ctr
, SPOOL_REG_PRINTENDTIME
, info2
->untiltime
);
2963 map_dword_into_ctr(ctr
, SPOOL_REG_PRIORITY
, info2
->priority
);
2965 map_bool_into_ctr(ctr
, SPOOL_REG_PRINTKEEPPRINTEDJOBS
,
2966 (info2
->attributes
&
2967 PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS
));
2969 switch (info2
->attributes
& 0x3) {
2971 ascii_str
= SPOOL_REGVAL_PRINTWHILESPOOLING
;
2974 ascii_str
= SPOOL_REGVAL_PRINTAFTERSPOOLED
;
2977 ascii_str
= SPOOL_REGVAL_PRINTDIRECT
;
2980 ascii_str
= "unknown";
2982 map_sz_into_ctr(ctr
, SPOOL_REG_PRINTSPOOLING
, ascii_str
);
2987 static void store_printer_guid(NT_PRINTER_INFO_LEVEL_2
*info2
,
2991 REGVAL_CTR
*ctr
=NULL
;
2993 /* find the DsSpooler key */
2994 if ((i
= lookup_printerkey(info2
->data
, SPOOL_DSSPOOLER_KEY
)) < 0)
2995 i
= add_new_printer_key(info2
->data
, SPOOL_DSSPOOLER_KEY
);
2996 ctr
= info2
->data
->keys
[i
].values
;
2998 regval_ctr_delvalue(ctr
, "objectGUID");
2999 regval_ctr_addvalue(ctr
, "objectGUID", REG_BINARY
,
3000 (char *) &guid
, sizeof(struct uuid
));
3003 static WERROR
nt_printer_publish_ads(ADS_STRUCT
*ads
,
3004 NT_PRINTER_INFO_LEVEL
*printer
)
3008 char *prt_dn
= NULL
, *srv_dn
, *srv_cn_0
;
3009 char *srv_dn_utf8
, **srv_cn_utf8
;
3012 const char *attrs
[] = {"objectGUID", NULL
};
3014 WERROR win_rc
= WERR_OK
;
3016 DEBUG(5, ("publishing printer %s\n", printer
->info_2
->printername
));
3018 /* figure out where to publish */
3019 ads_find_machine_acct(ads
, &res
, global_myname());
3021 /* We use ldap_get_dn here as we need the answer
3022 * in utf8 to call ldap_explode_dn(). JRA. */
3024 srv_dn_utf8
= ldap_get_dn(ads
->ld
, res
);
3027 return WERR_SERVER_UNAVAILABLE
;
3029 ads_msgfree(ads
, res
);
3030 srv_cn_utf8
= ldap_explode_dn(srv_dn_utf8
, 1);
3032 ldap_memfree(srv_dn_utf8
);
3034 return WERR_SERVER_UNAVAILABLE
;
3036 /* Now convert to CH_UNIX. */
3037 if (pull_utf8_allocate(&srv_dn
, srv_dn_utf8
) == (size_t)-1) {
3038 ldap_memfree(srv_dn_utf8
);
3039 ldap_memfree(srv_cn_utf8
);
3041 return WERR_SERVER_UNAVAILABLE
;
3043 if (pull_utf8_allocate(&srv_cn_0
, srv_cn_utf8
[0]) == (size_t)-1) {
3044 ldap_memfree(srv_dn_utf8
);
3045 ldap_memfree(srv_cn_utf8
);
3048 return WERR_SERVER_UNAVAILABLE
;
3051 ldap_memfree(srv_dn_utf8
);
3052 ldap_memfree(srv_cn_utf8
);
3054 asprintf(&prt_dn
, "cn=%s-%s,%s", srv_cn_0
,
3055 printer
->info_2
->sharename
, srv_dn
);
3058 SAFE_FREE(srv_cn_0
);
3060 /* build the ads mods */
3061 ctx
= talloc_init("nt_printer_publish_ads");
3067 mods
= ads_init_mods(ctx
);
3071 talloc_destroy(ctx
);
3075 get_local_printer_publishing_data(ctx
, &mods
, printer
->info_2
->data
);
3076 ads_mod_str(ctx
, &mods
, SPOOL_REG_PRINTERNAME
,
3077 printer
->info_2
->sharename
);
3080 ads_rc
= ads_mod_printer_entry(ads
, prt_dn
, ctx
, &mods
);
3081 if (ads_rc
.err
.rc
== LDAP_NO_SUCH_OBJECT
)
3082 ads_rc
= ads_add_printer_entry(ads
, prt_dn
, ctx
, &mods
);
3084 if (!ADS_ERR_OK(ads_rc
))
3085 DEBUG(3, ("error publishing %s: %s\n", printer
->info_2
->sharename
, ads_errstr(ads_rc
)));
3087 talloc_destroy(ctx
);
3089 /* retreive the guid and store it locally */
3090 if (ADS_ERR_OK(ads_search_dn(ads
, &res
, prt_dn
, attrs
))) {
3092 ads_pull_guid(ads
, res
, &guid
);
3093 ads_msgfree(ads
, res
);
3094 store_printer_guid(printer
->info_2
, guid
);
3095 win_rc
= mod_a_printer(printer
, 2);
3102 static WERROR
nt_printer_unpublish_ads(ADS_STRUCT
*ads
,
3103 NT_PRINTER_INFO_LEVEL
*printer
)
3107 char *prt_dn
= NULL
;
3109 DEBUG(5, ("unpublishing printer %s\n", printer
->info_2
->printername
));
3111 /* remove the printer from the directory */
3112 ads_rc
= ads_find_printer_on_server(ads
, &res
,
3113 printer
->info_2
->sharename
, global_myname());
3115 if (ADS_ERR_OK(ads_rc
) && ads_count_replies(ads
, res
)) {
3116 prt_dn
= ads_get_dn(ads
, res
);
3118 ads_msgfree(ads
, res
);
3121 ads_rc
= ads_del_dn(ads
, prt_dn
);
3122 ads_memfree(ads
, prt_dn
);
3125 ads_msgfree(ads
, res
);
3129 /****************************************************************************
3130 * Publish a printer in the directory
3132 * @param snum describing printer service
3133 * @return WERROR indicating status of publishing
3134 ***************************************************************************/
3136 WERROR
nt_printer_publish(Printer_entry
*print_hnd
, int snum
, int action
)
3139 ADS_STRUCT
*ads
= NULL
;
3140 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
3143 win_rc
= get_a_printer(print_hnd
, &printer
, 2, lp_servicename(snum
));
3144 if (!W_ERROR_IS_OK(win_rc
))
3148 case SPOOL_DS_PUBLISH
:
3149 case SPOOL_DS_UPDATE
:
3150 /* set the DsSpooler info and attributes */
3151 if (!(map_nt_printer_info2_to_dsspooler(printer
->info_2
))) {
3152 win_rc
= WERR_NOMEM
;
3156 printer
->info_2
->attributes
|= PRINTER_ATTRIBUTE_PUBLISHED
;
3158 case SPOOL_DS_UNPUBLISH
:
3159 printer
->info_2
->attributes
^= PRINTER_ATTRIBUTE_PUBLISHED
;
3162 win_rc
= WERR_NOT_SUPPORTED
;
3166 win_rc
= mod_a_printer(printer
, 2);
3167 if (!W_ERROR_IS_OK(win_rc
)) {
3168 DEBUG(3, ("err %d saving data\n", W_ERROR_V(win_rc
)));
3172 ads
= ads_init(lp_realm(), lp_workgroup(), NULL
);
3174 DEBUG(3, ("ads_init() failed\n"));
3175 win_rc
= WERR_SERVER_UNAVAILABLE
;
3178 setenv(KRB5_ENV_CCNAME
, "MEMORY:prtpub_cache", 1);
3179 SAFE_FREE(ads
->auth
.password
);
3180 ads
->auth
.password
= secrets_fetch_machine_password(lp_workgroup(),
3183 /* ads_connect() will find the DC for us */
3184 ads_rc
= ads_connect(ads
);
3185 if (!ADS_ERR_OK(ads_rc
)) {
3186 DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_rc
)));
3187 win_rc
= WERR_ACCESS_DENIED
;
3192 case SPOOL_DS_PUBLISH
:
3193 case SPOOL_DS_UPDATE
:
3194 win_rc
= nt_printer_publish_ads(ads
, printer
);
3196 case SPOOL_DS_UNPUBLISH
:
3197 win_rc
= nt_printer_unpublish_ads(ads
, printer
);
3202 free_a_printer(&printer
, 2);
3207 WERROR
check_published_printers(void)
3210 ADS_STRUCT
*ads
= NULL
;
3212 int n_services
= lp_numservices();
3213 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
3215 ads
= ads_init(lp_realm(), lp_workgroup(), NULL
);
3217 DEBUG(3, ("ads_init() failed\n"));
3218 return WERR_SERVER_UNAVAILABLE
;
3220 setenv(KRB5_ENV_CCNAME
, "MEMORY:prtpub_cache", 1);
3221 SAFE_FREE(ads
->auth
.password
);
3222 ads
->auth
.password
= secrets_fetch_machine_password(lp_workgroup(),
3225 /* ads_connect() will find the DC for us */
3226 ads_rc
= ads_connect(ads
);
3227 if (!ADS_ERR_OK(ads_rc
)) {
3228 DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_rc
)));
3230 return WERR_ACCESS_DENIED
;
3233 for (snum
= 0; snum
< n_services
; snum
++) {
3234 if (!(lp_snum_ok(snum
) && lp_print_ok(snum
)))
3237 if (W_ERROR_IS_OK(get_a_printer(NULL
, &printer
, 2,
3238 lp_servicename(snum
))) &&
3239 (printer
->info_2
->attributes
& PRINTER_ATTRIBUTE_PUBLISHED
))
3240 nt_printer_publish_ads(ads
, printer
);
3242 free_a_printer(&printer
, 2);
3249 BOOL
is_printer_published(Printer_entry
*print_hnd
, int snum
,
3252 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
3254 REGISTRY_VALUE
*guid_val
;
3258 win_rc
= get_a_printer(print_hnd
, &printer
, 2, lp_servicename(snum
));
3260 if (!W_ERROR_IS_OK(win_rc
) ||
3261 !(printer
->info_2
->attributes
& PRINTER_ATTRIBUTE_PUBLISHED
) ||
3262 ((i
= lookup_printerkey(printer
->info_2
->data
, SPOOL_DSSPOOLER_KEY
)) < 0) ||
3263 !(ctr
= printer
->info_2
->data
->keys
[i
].values
) ||
3264 !(guid_val
= regval_ctr_getvalue(ctr
, "objectGUID")))
3266 free_a_printer(&printer
, 2);
3270 /* fetching printer guids really ought to be a separate function.. */
3271 if (guid
&& regval_size(guid_val
) == sizeof(struct uuid
))
3272 memcpy(guid
, regval_data_p(guid_val
), sizeof(struct uuid
));
3274 free_a_printer(&printer
, 2);
3278 WERROR
nt_printer_publish(Printer_entry
*print_hnd
, int snum
, int action
)
3283 WERROR
check_published_printers(void)
3288 BOOL
is_printer_published(Printer_entry
*print_hnd
, int snum
,
3293 #endif /* HAVE_ADS */
3295 /****************************************************************************
3296 ***************************************************************************/
3298 WERROR
delete_all_printer_data( NT_PRINTER_INFO_LEVEL_2
*p2
, const char *key
)
3300 NT_PRINTER_DATA
*data
;
3302 int removed_keys
= 0;
3306 empty_slot
= data
->num_keys
;
3309 return WERR_INVALID_PARAM
;
3311 /* remove all keys */
3313 if ( !strlen(key
) ) {
3315 TALLOC_FREE( data
);
3319 DEBUG(8,("delete_all_printer_data: Removed all Printer Data from printer [%s]\n",
3325 /* remove a specific key (and all subkeys) */
3327 for ( i
=0; i
<data
->num_keys
; i
++ ) {
3328 if ( StrnCaseCmp( data
->keys
[i
].name
, key
, strlen(key
)) == 0 ) {
3329 DEBUG(8,("delete_all_printer_data: Removed all Printer Data from key [%s]\n",
3330 data
->keys
[i
].name
));
3332 TALLOC_FREE( data
->keys
[i
].name
);
3333 TALLOC_FREE( data
->keys
[i
].values
);
3335 /* mark the slot as empty */
3337 ZERO_STRUCTP( &data
->keys
[i
] );
3341 /* find the first empty slot */
3343 for ( i
=0; i
<data
->num_keys
; i
++ ) {
3344 if ( !data
->keys
[i
].name
) {
3351 if ( i
== data
->num_keys
)
3352 /* nothing was removed */
3353 return WERR_INVALID_PARAM
;
3355 /* move everything down */
3357 for ( i
=empty_slot
+1; i
<data
->num_keys
; i
++ ) {
3358 if ( data
->keys
[i
].name
) {
3359 memcpy( &data
->keys
[empty_slot
], &data
->keys
[i
], sizeof(NT_PRINTER_KEY
) );
3360 ZERO_STRUCTP( &data
->keys
[i
] );
3368 data
->num_keys
-= removed_keys
;
3370 /* sanity check to see if anything is left */
3372 if ( !data
->num_keys
) {
3373 DEBUG(8,("delete_all_printer_data: No keys left for printer [%s]\n", p2
->printername
));
3375 SAFE_FREE( data
->keys
);
3376 ZERO_STRUCTP( data
);
3382 /****************************************************************************
3383 ***************************************************************************/
3385 WERROR
delete_printer_data( NT_PRINTER_INFO_LEVEL_2
*p2
, const char *key
, const char *value
)
3387 WERROR result
= WERR_OK
;
3390 /* we must have names on non-zero length */
3392 if ( !key
|| !*key
|| !value
|| !*value
)
3393 return WERR_INVALID_NAME
;
3395 /* find the printer key first */
3397 key_index
= lookup_printerkey( p2
->data
, key
);
3398 if ( key_index
== -1 )
3401 /* make sure the value exists so we can return the correct error code */
3403 if ( !regval_ctr_getvalue( p2
->data
->keys
[key_index
].values
, value
) )
3404 return WERR_BADFILE
;
3406 regval_ctr_delvalue( p2
->data
->keys
[key_index
].values
, value
);
3408 DEBUG(8,("delete_printer_data: Removed key => [%s], value => [%s]\n",
3414 /****************************************************************************
3415 ***************************************************************************/
3417 WERROR
add_printer_data( NT_PRINTER_INFO_LEVEL_2
*p2
, const char *key
, const char *value
,
3418 uint32 type
, uint8
*data
, int real_len
)
3420 WERROR result
= WERR_OK
;
3423 /* we must have names on non-zero length */
3425 if ( !key
|| !*key
|| !value
|| !*value
)
3426 return WERR_INVALID_NAME
;
3428 /* find the printer key first */
3430 key_index
= lookup_printerkey( p2
->data
, key
);
3431 if ( key_index
== -1 )
3432 key_index
= add_new_printer_key( p2
->data
, key
);
3434 if ( key_index
== -1 )
3437 regval_ctr_addvalue( p2
->data
->keys
[key_index
].values
, value
,
3438 type
, (const char *)data
, real_len
);
3440 DEBUG(8,("add_printer_data: Added key => [%s], value => [%s], type=> [%d], size => [%d]\n",
3441 key
, value
, type
, real_len
));
3446 /****************************************************************************
3447 ***************************************************************************/
3449 REGISTRY_VALUE
* get_printer_data( NT_PRINTER_INFO_LEVEL_2
*p2
, const char *key
, const char *value
)
3453 if ( (key_index
= lookup_printerkey( p2
->data
, key
)) == -1 )
3456 DEBUG(8,("get_printer_data: Attempting to lookup key => [%s], value => [%s]\n",
3459 return regval_ctr_getvalue( p2
->data
->keys
[key_index
].values
, value
);
3462 /****************************************************************************
3463 Unpack a list of registry values frem the TDB
3464 ***************************************************************************/
3466 static int unpack_values(NT_PRINTER_DATA
*printer_data
, char *buf
, int buflen
)
3470 pstring string
, valuename
, keyname
;
3474 REGISTRY_VALUE
*regval_p
;
3477 /* add the "PrinterDriverData" key first for performance reasons */
3479 add_new_printer_key( printer_data
, SPOOL_PRINTERDATA_KEY
);
3481 /* loop and unpack the rest of the registry values */
3485 /* check to see if there are any more registry values */
3488 len
+= tdb_unpack(buf
+len
, buflen
-len
, "p", ®val_p
);
3492 /* unpack the next regval */
3494 len
+= tdb_unpack(buf
+len
, buflen
-len
, "fdB",
3500 /* lookup for subkey names which have a type of REG_NONE */
3501 /* there's no data with this entry */
3503 if ( type
== REG_NONE
) {
3504 if ( (key_index
=lookup_printerkey( printer_data
, string
)) == -1 )
3505 add_new_printer_key( printer_data
, string
);
3510 * break of the keyname from the value name.
3511 * Valuenames can have embedded '\'s so be careful.
3512 * only support one level of keys. See the
3513 * "Konica Fiery S300 50C-K v1.1. enu" 2k driver.
3517 str
= strchr_m( string
, '\\');
3519 /* Put in "PrinterDriverData" is no key specified */
3522 pstrcpy( keyname
, SPOOL_PRINTERDATA_KEY
);
3523 pstrcpy( valuename
, string
);
3527 pstrcpy( keyname
, string
);
3528 pstrcpy( valuename
, str
+1 );
3531 /* see if we need a new key */
3533 if ( (key_index
=lookup_printerkey( printer_data
, keyname
)) == -1 )
3534 key_index
= add_new_printer_key( printer_data
, keyname
);
3536 if ( key_index
== -1 ) {
3537 DEBUG(0,("unpack_values: Failed to allocate a new key [%s]!\n",
3542 /* add the new value */
3544 regval_ctr_addvalue( printer_data
->keys
[key_index
].values
, valuename
, type
, (const char *)data_p
, size
);
3546 SAFE_FREE(data_p
); /* 'B' option to tdbpack does a malloc() */
3548 DEBUG(8,("specific: [%s:%s], len: %d\n", keyname
, valuename
, size
));
3554 /****************************************************************************
3555 ***************************************************************************/
3557 static void map_to_os2_driver(fstring drivername
)
3559 static BOOL initialised
=False
;
3560 static fstring last_from
,last_to
;
3561 char *mapfile
= lp_os2_driver_map();
3562 char **lines
= NULL
;
3566 if (!strlen(drivername
))
3573 *last_from
= *last_to
= 0;
3577 if (strequal(drivername
,last_from
)) {
3578 DEBUG(3,("Mapped Windows driver %s to OS/2 driver %s\n",drivername
,last_to
));
3579 fstrcpy(drivername
,last_to
);
3583 lines
= file_lines_load(mapfile
, &numlines
,0);
3584 if (numlines
== 0 || lines
== NULL
) {
3585 DEBUG(0,("No entries in OS/2 driver map %s\n",mapfile
));
3590 DEBUG(4,("Scanning OS/2 driver map %s\n",mapfile
));
3592 for( i
= 0; i
< numlines
; i
++) {
3593 char *nt_name
= lines
[i
];
3594 char *os2_name
= strchr(nt_name
,'=');
3601 while (isspace(*nt_name
))
3604 if (!*nt_name
|| strchr("#;",*nt_name
))
3608 int l
= strlen(nt_name
);
3609 while (l
&& isspace(nt_name
[l
-1])) {
3615 while (isspace(*os2_name
))
3619 int l
= strlen(os2_name
);
3620 while (l
&& isspace(os2_name
[l
-1])) {
3626 if (strequal(nt_name
,drivername
)) {
3627 DEBUG(3,("Mapped windows driver %s to os2 driver%s\n",drivername
,os2_name
));
3628 fstrcpy(last_from
,drivername
);
3629 fstrcpy(last_to
,os2_name
);
3630 fstrcpy(drivername
,os2_name
);
3631 file_lines_free(lines
);
3636 file_lines_free(lines
);
3639 /****************************************************************************
3640 Get a default printer info 2 struct.
3641 ****************************************************************************/
3642 static WERROR
get_a_printer_2_default(NT_PRINTER_INFO_LEVEL_2
*info
, const char *servername
, const char* sharename
)
3646 snum
= lp_servicenumber(sharename
);
3648 slprintf(info
->servername
, sizeof(info
->servername
)-1, "\\\\%s", servername
);
3649 slprintf(info
->printername
, sizeof(info
->printername
)-1, "\\\\%s\\%s",
3650 servername
, sharename
);
3651 fstrcpy(info
->sharename
, sharename
);
3652 fstrcpy(info
->portname
, SAMBA_PRINTER_PORT_NAME
);
3654 /* by setting the driver name to an empty string, a local NT admin
3655 can now run the **local** APW to install a local printer driver
3656 for a Samba shared printer in 2.2. Without this, drivers **must** be
3657 installed on the Samba server for NT clients --jerry */
3658 #if 0 /* JERRY --do not uncomment-- */
3659 if (!*info
->drivername
)
3660 fstrcpy(info
->drivername
, "NO DRIVER AVAILABLE FOR THIS PRINTER");
3664 DEBUG(10,("get_a_printer_2_default: driver name set to [%s]\n", info
->drivername
));
3666 pstrcpy(info
->comment
, "");
3667 fstrcpy(info
->printprocessor
, "winprint");
3668 fstrcpy(info
->datatype
, "RAW");
3670 info
->attributes
= PRINTER_ATTRIBUTE_SAMBA
;
3672 info
->starttime
= 0; /* Minutes since 12:00am GMT */
3673 info
->untiltime
= 0; /* Minutes since 12:00am GMT */
3675 info
->default_priority
= 1;
3676 info
->setuptime
= (uint32
)time(NULL
);
3679 * I changed this as I think it is better to have a generic
3680 * DEVMODE than to crash Win2k explorer.exe --jerry
3681 * See the HP Deskjet 990c Win2k drivers for an example.
3683 * However the default devmode appears to cause problems
3684 * with the HP CLJ 8500 PCL driver. Hence the addition of
3685 * the "default devmode" parameter --jerry 22/01/2002
3688 if (lp_default_devmode(snum
)) {
3689 if ((info
->devmode
= construct_nt_devicemode(info
->printername
)) == NULL
) {
3693 info
->devmode
= NULL
;
3696 if (!nt_printing_getsec(info
, sharename
, &info
->secdesc_buf
)) {
3704 free_nt_devicemode(&info
->devmode
);
3706 return WERR_ACCESS_DENIED
;
3709 /****************************************************************************
3710 ****************************************************************************/
3711 static WERROR
get_a_printer_2(NT_PRINTER_INFO_LEVEL_2
*info
, const char *servername
, const char *sharename
)
3714 int snum
= lp_servicenumber(sharename
);
3715 TDB_DATA kbuf
, dbuf
;
3716 fstring printername
;
3717 char adevice
[MAXDEVICENAME
];
3719 kbuf
= make_printer_tdbkey( sharename
);
3721 dbuf
= tdb_fetch(tdb_printers
, kbuf
);
3723 return get_a_printer_2_default(info
, servername
, sharename
);
3726 len
+= tdb_unpack(dbuf
.dptr
+len
, dbuf
.dsize
-len
, "dddddddddddfffffPfffff",
3729 &info
->default_priority
,
3736 &info
->c_setprinter
,
3746 info
->printprocessor
,
3750 /* Samba has to have shared raw drivers. */
3751 info
->attributes
|= PRINTER_ATTRIBUTE_SAMBA
;
3752 info
->attributes
&= ~PRINTER_ATTRIBUTE_NOT_SAMBA
;
3754 /* Restore the stripped strings. */
3755 slprintf(info
->servername
, sizeof(info
->servername
)-1, "\\\\%s", servername
);
3757 if ( lp_force_printername(snum
) ) {
3758 slprintf(printername
, sizeof(printername
)-1, "\\\\%s\\%s", servername
, sharename
);
3760 slprintf(printername
, sizeof(printername
)-1, "\\\\%s\\%s", servername
, info
->printername
);
3763 fstrcpy(info
->printername
, printername
);
3765 len
+= unpack_devicemode(&info
->devmode
,dbuf
.dptr
+len
, dbuf
.dsize
-len
);
3768 * Some client drivers freak out if there is a NULL devmode
3769 * (probably the driver is not checking before accessing
3770 * the devmode pointer) --jerry
3772 * See comments in get_a_printer_2_default()
3775 if (lp_default_devmode(snum
) && !info
->devmode
) {
3776 DEBUG(8,("get_a_printer_2: Constructing a default device mode for [%s]\n",
3778 info
->devmode
= construct_nt_devicemode(printername
);
3781 slprintf( adevice
, sizeof(adevice
), "%s", info
->printername
);
3782 if (info
->devmode
) {
3783 fstrcpy(info
->devmode
->devicename
, adevice
);
3786 if ( !(info
->data
= TALLOC_ZERO_P( info
, NT_PRINTER_DATA
)) ) {
3787 DEBUG(0,("unpack_values: talloc() failed!\n"));
3788 SAFE_FREE(dbuf
.dptr
);
3791 len
+= unpack_values( info
->data
, dbuf
.dptr
+len
, dbuf
.dsize
-len
);
3793 /* This will get the current RPC talloc context, but we should be
3794 passing this as a parameter... fixme... JRA ! */
3796 if (!nt_printing_getsec(info
, sharename
, &info
->secdesc_buf
)) {
3797 SAFE_FREE(dbuf
.dptr
);
3801 /* Fix for OS/2 drivers. */
3803 if (get_remote_arch() == RA_OS2
) {
3804 map_to_os2_driver(info
->drivername
);
3807 SAFE_FREE(dbuf
.dptr
);
3809 DEBUG(9,("Unpacked printer [%s] name [%s] running driver [%s]\n",
3810 sharename
, info
->printername
, info
->drivername
));
3815 /****************************************************************************
3816 Debugging function, dump at level 6 the struct in the logs.
3817 ****************************************************************************/
3818 static uint32
dump_a_printer(NT_PRINTER_INFO_LEVEL
*printer
, uint32 level
)
3821 NT_PRINTER_INFO_LEVEL_2
*info2
;
3823 DEBUG(106,("Dumping printer at level [%d]\n", level
));
3828 if (printer
->info_2
== NULL
)
3832 info2
=printer
->info_2
;
3834 DEBUGADD(106,("attributes:[%d]\n", info2
->attributes
));
3835 DEBUGADD(106,("priority:[%d]\n", info2
->priority
));
3836 DEBUGADD(106,("default_priority:[%d]\n", info2
->default_priority
));
3837 DEBUGADD(106,("starttime:[%d]\n", info2
->starttime
));
3838 DEBUGADD(106,("untiltime:[%d]\n", info2
->untiltime
));
3839 DEBUGADD(106,("status:[%d]\n", info2
->status
));
3840 DEBUGADD(106,("cjobs:[%d]\n", info2
->cjobs
));
3841 DEBUGADD(106,("averageppm:[%d]\n", info2
->averageppm
));
3842 DEBUGADD(106,("changeid:[%d]\n", info2
->changeid
));
3843 DEBUGADD(106,("c_setprinter:[%d]\n", info2
->c_setprinter
));
3844 DEBUGADD(106,("setuptime:[%d]\n", info2
->setuptime
));
3846 DEBUGADD(106,("servername:[%s]\n", info2
->servername
));
3847 DEBUGADD(106,("printername:[%s]\n", info2
->printername
));
3848 DEBUGADD(106,("sharename:[%s]\n", info2
->sharename
));
3849 DEBUGADD(106,("portname:[%s]\n", info2
->portname
));
3850 DEBUGADD(106,("drivername:[%s]\n", info2
->drivername
));
3851 DEBUGADD(106,("comment:[%s]\n", info2
->comment
));
3852 DEBUGADD(106,("location:[%s]\n", info2
->location
));
3853 DEBUGADD(106,("sepfile:[%s]\n", info2
->sepfile
));
3854 DEBUGADD(106,("printprocessor:[%s]\n", info2
->printprocessor
));
3855 DEBUGADD(106,("datatype:[%s]\n", info2
->datatype
));
3856 DEBUGADD(106,("parameters:[%s]\n", info2
->parameters
));
3862 DEBUGADD(106,("dump_a_printer: Level %u not implemented\n", (unsigned int)level
));
3870 /****************************************************************************
3871 Update the changeid time.
3872 This is SO NASTY as some drivers need this to change, others need it
3873 static. This value will change every second, and I must hope that this
3874 is enough..... DON'T CHANGE THIS CODE WITHOUT A TEST MATRIX THE SIZE OF
3876 ****************************************************************************/
3878 static uint32
rev_changeid(void)
3882 get_process_uptime(&tv
);
3885 /* Return changeid as msec since spooler restart */
3886 return tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
3889 * This setting seems to work well but is too untested
3890 * to replace the above calculation. Left in for experiementation
3891 * of the reader --jerry (Tue Mar 12 09:15:05 CST 2002)
3893 return tv
.tv_sec
* 10 + tv
.tv_usec
/ 100000;
3899 * The function below are the high level ones.
3900 * only those ones must be called from the spoolss code.
3904 /****************************************************************************
3905 Modify a printer. This is called from SETPRINTERDATA/DELETEPRINTERDATA.
3906 ****************************************************************************/
3908 WERROR
mod_a_printer(NT_PRINTER_INFO_LEVEL
*printer
, uint32 level
)
3912 dump_a_printer(printer
, level
);
3918 * Update the changestamp. Emperical tests show that the
3919 * ChangeID is always updated,but c_setprinter is
3920 * global spooler variable (not per printer).
3923 /* ChangeID **must** be increasing over the lifetime
3924 of client's spoolss service in order for the
3925 client's cache to show updates */
3927 printer
->info_2
->changeid
= rev_changeid();
3930 * Because one day someone will ask:
3931 * NT->NT An admin connection to a remote
3932 * printer show changes imeediately in
3933 * the properities dialog
3935 * A non-admin connection will only show the
3936 * changes after viewing the properites page
3937 * 2 times. Seems to be related to a
3938 * race condition in the client between the spooler
3939 * updating the local cache and the Explorer.exe GUI
3940 * actually displaying the properties.
3942 * This is fixed in Win2k. admin/non-admin
3943 * connections both display changes immediately.
3948 result
=update_a_printer_2(printer
->info_2
);
3953 result
=WERR_UNKNOWN_LEVEL
;
3960 /****************************************************************************
3961 Initialize printer devmode & data with previously saved driver init values.
3962 ****************************************************************************/
3964 static BOOL
set_driver_init_2( NT_PRINTER_INFO_LEVEL_2
*info_ptr
)
3968 TDB_DATA kbuf
, dbuf
;
3969 NT_PRINTER_INFO_LEVEL_2 info
;
3975 * Delete any printer data 'values' already set. When called for driver
3976 * replace, there will generally be some, but during an add printer, there
3977 * should not be any (if there are delete them).
3980 if ( info_ptr
->data
)
3981 delete_all_printer_data( info_ptr
, "" );
3983 slprintf(key
, sizeof(key
)-1, "%s%s", DRIVER_INIT_PREFIX
, info_ptr
->drivername
);
3986 kbuf
.dsize
= strlen(key
)+1;
3988 dbuf
= tdb_fetch(tdb_drivers
, kbuf
);
3991 * When changing to a driver that has no init info in the tdb, remove
3992 * the previous drivers init info and leave the new on blank.
3994 free_nt_devicemode(&info_ptr
->devmode
);
3999 * Get the saved DEVMODE..
4002 len
+= unpack_devicemode(&info
.devmode
,dbuf
.dptr
+len
, dbuf
.dsize
-len
);
4005 * The saved DEVMODE contains the devicename from the printer used during
4006 * the initialization save. Change it to reflect the new printer.
4009 if ( info
.devmode
) {
4010 ZERO_STRUCT(info
.devmode
->devicename
);
4011 fstrcpy(info
.devmode
->devicename
, info_ptr
->printername
);
4015 * NT/2k does not change out the entire DeviceMode of a printer
4016 * when changing the driver. Only the driverextra, private, &
4017 * driverversion fields. --jerry (Thu Mar 14 08:58:43 CST 2002)
4019 * Later examination revealed that Windows NT/2k does reset the
4020 * the printer's device mode, bit **only** when you change a
4021 * property of the device mode such as the page orientation.
4026 /* Bind the saved DEVMODE to the new the printer */
4028 free_nt_devicemode(&info_ptr
->devmode
);
4029 info_ptr
->devmode
= info
.devmode
;
4031 DEBUG(10,("set_driver_init_2: Set printer [%s] init %s DEVMODE for driver [%s]\n",
4032 info_ptr
->printername
, info_ptr
->devmode
?"VALID":"NULL", info_ptr
->drivername
));
4034 /* Add the printer data 'values' to the new printer */
4036 if ( !(info_ptr
->data
= TALLOC_ZERO_P( info_ptr
, NT_PRINTER_DATA
)) ) {
4037 DEBUG(0,("set_driver_init_2: talloc() failed!\n"));
4041 len
+= unpack_values( info_ptr
->data
, dbuf
.dptr
+len
, dbuf
.dsize
-len
);
4044 SAFE_FREE(dbuf
.dptr
);
4049 /****************************************************************************
4050 Initialize printer devmode & data with previously saved driver init values.
4051 When a printer is created using AddPrinter, the drivername bound to the
4052 printer is used to lookup previously saved driver initialization info, which
4053 is bound to the new printer.
4054 ****************************************************************************/
4056 BOOL
set_driver_init(NT_PRINTER_INFO_LEVEL
*printer
, uint32 level
)
4058 BOOL result
= False
;
4062 result
= set_driver_init_2(printer
->info_2
);
4066 DEBUG(0,("set_driver_init: Programmer's error! Unknown driver_init level [%d]\n",
4074 /****************************************************************************
4075 Delete driver init data stored for a specified driver
4076 ****************************************************************************/
4078 BOOL
del_driver_init(char *drivername
)
4083 if (!drivername
|| !*drivername
) {
4084 DEBUG(3,("del_driver_init: No drivername specified!\n"));
4088 slprintf(key
, sizeof(key
)-1, "%s%s", DRIVER_INIT_PREFIX
, drivername
);
4091 kbuf
.dsize
= strlen(key
)+1;
4093 DEBUG(6,("del_driver_init: Removing driver init data for [%s]\n", drivername
));
4095 return (tdb_delete(tdb_drivers
, kbuf
) == 0);
4098 /****************************************************************************
4099 Pack up the DEVMODE and values for a printer into a 'driver init' entry
4100 in the tdb. Note: this is different from the driver entry and the printer
4101 entry. There should be a single driver init entry for each driver regardless
4102 of whether it was installed from NT or 2K. Technically, they should be
4103 different, but they work out to the same struct.
4104 ****************************************************************************/
4106 static uint32
update_driver_init_2(NT_PRINTER_INFO_LEVEL_2
*info
)
4110 int buflen
, len
, ret
;
4111 TDB_DATA kbuf
, dbuf
;
4118 len
+= pack_devicemode(info
->devmode
, buf
+len
, buflen
-len
);
4120 len
+= pack_values( info
->data
, buf
+len
, buflen
-len
);
4123 buf
= (char *)SMB_REALLOC(buf
, len
);
4125 DEBUG(0, ("update_driver_init_2: failed to enlarge buffer!\n"));
4133 slprintf(key
, sizeof(key
)-1, "%s%s", DRIVER_INIT_PREFIX
, info
->drivername
);
4136 kbuf
.dsize
= strlen(key
)+1;
4140 ret
= tdb_store(tdb_drivers
, kbuf
, dbuf
, TDB_REPLACE
);
4144 DEBUG(8, ("update_driver_init_2: error updating printer init to tdb on disk\n"));
4148 DEBUG(10,("update_driver_init_2: Saved printer [%s] init DEVMODE & values for driver [%s]\n",
4149 info
->sharename
, info
->drivername
));
4154 /****************************************************************************
4155 Update (i.e. save) the driver init info (DEVMODE and values) for a printer
4156 ****************************************************************************/
4158 static uint32
update_driver_init(NT_PRINTER_INFO_LEVEL
*printer
, uint32 level
)
4162 dump_a_printer(printer
, level
);
4166 result
= update_driver_init_2(printer
->info_2
);
4176 /****************************************************************************
4177 Convert the printer data value, a REG_BINARY array, into an initialization
4178 DEVMODE. Note: the array must be parsed as if it was a DEVMODE in an rpc...
4179 got to keep the endians happy :).
4180 ****************************************************************************/
4182 static BOOL
convert_driver_init( TALLOC_CTX
*ctx
, NT_DEVICEMODE
*nt_devmode
, uint8
*data
, uint32 data_len
)
4184 BOOL result
= False
;
4188 ZERO_STRUCT(devmode
);
4190 prs_init(&ps
, 0, ctx
, UNMARSHALL
);
4191 ps
.data_p
= (char *)data
;
4192 ps
.buffer_size
= data_len
;
4194 if (spoolss_io_devmode("phantom DEVMODE", &ps
, 0, &devmode
))
4195 result
= convert_devicemode("", &devmode
, &nt_devmode
);
4197 DEBUG(10,("convert_driver_init: error parsing DEVMODE\n"));
4202 /****************************************************************************
4203 Set the DRIVER_INIT info in the tdb. Requires Win32 client code that:
4205 1. Use the driver's config DLL to this UNC printername and:
4206 a. Call DrvPrintEvent with PRINTER_EVENT_INITIALIZE
4207 b. Call DrvConvertDevMode with CDM_DRIVER_DEFAULT to get default DEVMODE
4208 2. Call SetPrinterData with the 'magic' key and the DEVMODE as data.
4210 The last step triggers saving the "driver initialization" information for
4211 this printer into the tdb. Later, new printers that use this driver will
4212 have this initialization information bound to them. This simulates the
4213 driver initialization, as if it had run on the Samba server (as it would
4216 The Win32 client side code requirement sucks! But until we can run arbitrary
4217 Win32 printer driver code on any Unix that Samba runs on, we are stuck with it.
4219 It would have been easier to use SetPrinter because all the UNMARSHALLING of
4220 the DEVMODE is done there, but 2K/XP clients do not set the DEVMODE... think
4221 about it and you will realize why. JRR 010720
4222 ****************************************************************************/
4224 static WERROR
save_driver_init_2(NT_PRINTER_INFO_LEVEL
*printer
, uint8
*data
, uint32 data_len
)
4226 WERROR status
= WERR_OK
;
4227 TALLOC_CTX
*ctx
= NULL
;
4228 NT_DEVICEMODE
*nt_devmode
= NULL
;
4229 NT_DEVICEMODE
*tmp_devmode
= printer
->info_2
->devmode
;
4232 * When the DEVMODE is already set on the printer, don't try to unpack it.
4234 DEBUG(8,("save_driver_init_2: Enter...\n"));
4236 if ( !printer
->info_2
->devmode
&& data_len
) {
4238 * Set devmode on printer info, so entire printer initialization can be
4242 if ((ctx
= talloc_init("save_driver_init_2")) == NULL
)
4245 if ((nt_devmode
= SMB_MALLOC_P(NT_DEVICEMODE
)) == NULL
) {
4246 status
= WERR_NOMEM
;
4250 ZERO_STRUCTP(nt_devmode
);
4253 * The DEVMODE is held in the 'data' component of the param in raw binary.
4254 * Convert it to to a devmode structure
4256 if ( !convert_driver_init( ctx
, nt_devmode
, data
, data_len
)) {
4257 DEBUG(10,("save_driver_init_2: error converting DEVMODE\n"));
4258 status
= WERR_INVALID_PARAM
;
4262 printer
->info_2
->devmode
= nt_devmode
;
4266 * Pack up and add (or update) the DEVMODE and any current printer data to
4267 * a 'driver init' element in the tdb
4271 if ( update_driver_init(printer
, 2) != 0 ) {
4272 DEBUG(10,("save_driver_init_2: error updating DEVMODE\n"));
4273 status
= WERR_NOMEM
;
4278 * If driver initialization info was successfully saved, set the current
4279 * printer to match it. This allows initialization of the current printer
4280 * as well as the driver.
4282 status
= mod_a_printer(printer
, 2);
4283 if (!W_ERROR_IS_OK(status
)) {
4284 DEBUG(10,("save_driver_init_2: error setting DEVMODE on printer [%s]\n",
4285 printer
->info_2
->printername
));
4289 talloc_destroy(ctx
);
4290 free_nt_devicemode( &nt_devmode
);
4292 printer
->info_2
->devmode
= tmp_devmode
;
4297 /****************************************************************************
4298 Update the driver init info (DEVMODE and specifics) for a printer
4299 ****************************************************************************/
4301 WERROR
save_driver_init(NT_PRINTER_INFO_LEVEL
*printer
, uint32 level
, uint8
*data
, uint32 data_len
)
4303 WERROR status
= WERR_OK
;
4307 status
= save_driver_init_2( printer
, data
, data_len
);
4310 status
= WERR_UNKNOWN_LEVEL
;
4317 /****************************************************************************
4318 Get a NT_PRINTER_INFO_LEVEL struct. It returns malloced memory.
4320 Previously the code had a memory allocation problem because it always
4321 used the TALLOC_CTX from the Printer_entry*. This context lasts
4322 as a long as the original handle is open. So if the client made a lot
4323 of getprinter[data]() calls, the memory usage would climb. Now we use
4324 a short lived TALLOC_CTX for printer_info_2 objects returned. We
4325 still use the Printer_entry->ctx for maintaining the cache copy though
4326 since that object must live as long as the handle by definition.
4329 ****************************************************************************/
4331 WERROR
get_a_printer( Printer_entry
*print_hnd
, NT_PRINTER_INFO_LEVEL
**pp_printer
, uint32 level
,
4332 const char *sharename
)
4337 DEBUG(10,("get_a_printer: [%s] level %u\n", sharename
, (unsigned int)level
));
4339 if ( !(*pp_printer
= TALLOC_ZERO_P(NULL
, NT_PRINTER_INFO_LEVEL
)) ) {
4340 DEBUG(0,("get_a_printer: talloc() fail.\n"));
4346 if ( !((*pp_printer
)->info_2
= TALLOC_ZERO_P(*pp_printer
, NT_PRINTER_INFO_LEVEL_2
)) ) {
4347 DEBUG(0,("get_a_printer: talloc() fail.\n"));
4348 TALLOC_FREE( *pp_printer
);
4353 fstrcpy( servername
, print_hnd
->servername
);
4355 fstrcpy( servername
, "%L" );
4356 standard_sub_basic( "", servername
, sizeof(servername
)-1 );
4359 result
= get_a_printer_2( (*pp_printer
)->info_2
, servername
, sharename
);
4362 /* we have a new printer now. Save it with this handle */
4364 if ( !W_ERROR_IS_OK(result
) ) {
4365 TALLOC_FREE( *pp_printer
);
4366 DEBUG(10,("get_a_printer: [%s] level %u returning %s\n",
4367 sharename
, (unsigned int)level
, dos_errstr(result
)));
4371 dump_a_printer( *pp_printer
, level
);
4376 TALLOC_FREE( *pp_printer
);
4377 return WERR_UNKNOWN_LEVEL
;
4383 /****************************************************************************
4384 Deletes a NT_PRINTER_INFO_LEVEL struct.
4385 ****************************************************************************/
4387 uint32
free_a_printer(NT_PRINTER_INFO_LEVEL
**pp_printer
, uint32 level
)
4389 NT_PRINTER_INFO_LEVEL
*printer
= *pp_printer
;
4396 if ( printer
->info_2
)
4397 free_nt_printer_info_level_2(&printer
->info_2
);
4401 DEBUG(0,("free_a_printer: unknown level! [%d]\n", level
));
4405 TALLOC_FREE(*pp_printer
);
4410 /****************************************************************************
4411 ****************************************************************************/
4412 uint32
add_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver
, uint32 level
)
4415 DEBUG(104,("adding a printer at level [%d]\n", level
));
4416 dump_a_printer_driver(driver
, level
);
4420 result
=add_a_printer_driver_3(driver
.info_3
);
4424 result
=add_a_printer_driver_6(driver
.info_6
);
4434 /****************************************************************************
4435 ****************************************************************************/
4437 WERROR
get_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL
*driver
, uint32 level
,
4438 fstring drivername
, const char *architecture
, uint32 version
)
4444 /* Sometime we just want any version of the driver */
4446 if ( version
== DRIVER_ANY_VERSION
) {
4447 /* look for Win2k first and then for NT4 */
4448 result
= get_a_printer_driver_3(&driver
->info_3
, drivername
,
4451 if ( !W_ERROR_IS_OK(result
) ) {
4452 result
= get_a_printer_driver_3( &driver
->info_3
,
4453 drivername
, architecture
, 2 );
4456 result
= get_a_printer_driver_3(&driver
->info_3
, drivername
,
4457 architecture
, version
);
4466 if (W_ERROR_IS_OK(result
))
4467 dump_a_printer_driver(*driver
, level
);
4472 /****************************************************************************
4473 ****************************************************************************/
4474 uint32
free_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver
, uint32 level
)
4481 NT_PRINTER_DRIVER_INFO_LEVEL_3
*info3
;
4482 if (driver
.info_3
!= NULL
)
4484 info3
=driver
.info_3
;
4485 SAFE_FREE(info3
->dependentfiles
);
4486 ZERO_STRUCTP(info3
);
4496 NT_PRINTER_DRIVER_INFO_LEVEL_6
*info6
;
4497 if (driver
.info_6
!= NULL
) {
4498 info6
=driver
.info_6
;
4499 SAFE_FREE(info6
->dependentfiles
);
4500 SAFE_FREE(info6
->previousnames
);
4501 ZERO_STRUCTP(info6
);
4517 /****************************************************************************
4518 Determine whether or not a particular driver is currently assigned
4520 ****************************************************************************/
4522 BOOL
printer_driver_in_use ( NT_PRINTER_DRIVER_INFO_LEVEL_3
*info_3
)
4525 int n_services
= lp_numservices();
4526 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
4527 BOOL in_use
= False
;
4532 DEBUG(10,("printer_driver_in_use: Beginning search through ntprinters.tdb...\n"));
4534 /* loop through the printers.tdb and check for the drivername */
4536 for (snum
=0; snum
<n_services
&& !in_use
; snum
++) {
4537 if ( !(lp_snum_ok(snum
) && lp_print_ok(snum
) ) )
4540 if ( !W_ERROR_IS_OK(get_a_printer(NULL
, &printer
, 2, lp_servicename(snum
))) )
4543 if ( strequal(info_3
->name
, printer
->info_2
->drivername
) )
4546 free_a_printer( &printer
, 2 );
4549 DEBUG(10,("printer_driver_in_use: Completed search through ntprinters.tdb...\n"));
4552 NT_PRINTER_DRIVER_INFO_LEVEL d
;
4555 DEBUG(5,("printer_driver_in_use: driver \"%s\" is currently in use\n", info_3
->name
));
4557 /* we can still remove the driver if there is one of
4558 "Windows NT x86" version 2 or 3 left */
4560 if ( !strequal( "Windows NT x86", info_3
->environment
) ) {
4561 werr
= get_a_printer_driver( &d
, 3, info_3
->name
, "Windows NT x86", DRIVER_ANY_VERSION
);
4564 switch ( info_3
->cversion
) {
4566 werr
= get_a_printer_driver( &d
, 3, info_3
->name
, "Windows NT x86", 3 );
4569 werr
= get_a_printer_driver( &d
, 3, info_3
->name
, "Windows NT x86", 2 );
4572 DEBUG(0,("printer_driver_in_use: ERROR! unknown driver version (%d)\n",
4574 werr
= WERR_UNKNOWN_PRINTER_DRIVER
;
4579 /* now check the error code */
4581 if ( W_ERROR_IS_OK(werr
) ) {
4582 /* it's ok to remove the driver, we have other architctures left */
4584 free_a_printer_driver( d
, 3 );
4588 /* report that the driver is not in use by default */
4594 /**********************************************************************
4595 Check to see if a ogiven file is in use by *info
4596 *********************************************************************/
4598 static BOOL
drv_file_in_use( char* file
, NT_PRINTER_DRIVER_INFO_LEVEL_3
*info
)
4605 if ( strequal(file
, info
->driverpath
) )
4608 if ( strequal(file
, info
->datafile
) )
4611 if ( strequal(file
, info
->configfile
) )
4614 if ( strequal(file
, info
->helpfile
) )
4617 /* see of there are any dependent files to examine */
4619 if ( !info
->dependentfiles
)
4622 while ( *info
->dependentfiles
[i
] ) {
4623 if ( strequal(file
, info
->dependentfiles
[i
]) )
4632 /**********************************************************************
4633 Utility function to remove the dependent file pointed to by the
4634 input parameter from the list
4635 *********************************************************************/
4637 static void trim_dependent_file( fstring files
[], int idx
)
4640 /* bump everything down a slot */
4642 while( *files
[idx
+1] ) {
4643 fstrcpy( files
[idx
], files
[idx
+1] );
4652 /**********************************************************************
4653 Check if any of the files used by src are also used by drv
4654 *********************************************************************/
4656 static BOOL
trim_overlap_drv_files( NT_PRINTER_DRIVER_INFO_LEVEL_3
*src
,
4657 NT_PRINTER_DRIVER_INFO_LEVEL_3
*drv
)
4659 BOOL in_use
= False
;
4665 /* check each file. Remove it from the src structure if it overlaps */
4667 if ( drv_file_in_use(src
->driverpath
, drv
) ) {
4669 DEBUG(10,("Removing driverfile [%s] from list\n", src
->driverpath
));
4670 fstrcpy( src
->driverpath
, "" );
4673 if ( drv_file_in_use(src
->datafile
, drv
) ) {
4675 DEBUG(10,("Removing datafile [%s] from list\n", src
->datafile
));
4676 fstrcpy( src
->datafile
, "" );
4679 if ( drv_file_in_use(src
->configfile
, drv
) ) {
4681 DEBUG(10,("Removing configfile [%s] from list\n", src
->configfile
));
4682 fstrcpy( src
->configfile
, "" );
4685 if ( drv_file_in_use(src
->helpfile
, drv
) ) {
4687 DEBUG(10,("Removing helpfile [%s] from list\n", src
->helpfile
));
4688 fstrcpy( src
->helpfile
, "" );
4691 /* are there any dependentfiles to examine? */
4693 if ( !src
->dependentfiles
)
4696 while ( *src
->dependentfiles
[i
] ) {
4697 if ( drv_file_in_use(src
->dependentfiles
[i
], drv
) ) {
4699 DEBUG(10,("Removing [%s] from dependent file list\n", src
->dependentfiles
[i
]));
4700 trim_dependent_file( src
->dependentfiles
, i
);
4708 /****************************************************************************
4709 Determine whether or not a particular driver files are currently being
4710 used by any other driver.
4712 Return value is True if any files were in use by other drivers
4713 and False otherwise.
4715 Upon return, *info has been modified to only contain the driver files
4716 which are not in use
4717 ****************************************************************************/
4719 BOOL
printer_driver_files_in_use ( NT_PRINTER_DRIVER_INFO_LEVEL_3
*info
)
4724 fstring
*list
= NULL
;
4725 NT_PRINTER_DRIVER_INFO_LEVEL driver
;
4730 version
= info
->cversion
;
4732 /* loop over all driver versions */
4734 DEBUG(5,("printer_driver_files_in_use: Beginning search through ntdrivers.tdb...\n"));
4736 /* get the list of drivers */
4739 ndrivers
= get_ntdrivers(&list
, info
->environment
, version
);
4741 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
4742 ndrivers
, info
->environment
, version
));
4744 /* check each driver for overlap in files */
4746 for (i
=0; i
<ndrivers
; i
++) {
4747 DEBUGADD(5,("\tdriver: [%s]\n", list
[i
]));
4749 ZERO_STRUCT(driver
);
4751 if ( !W_ERROR_IS_OK(get_a_printer_driver(&driver
, 3, list
[i
], info
->environment
, version
)) ) {
4756 /* check if d2 uses any files from d1 */
4757 /* only if this is a different driver than the one being deleted */
4759 if ( !strequal(info
->name
, driver
.info_3
->name
) ) {
4760 if ( trim_overlap_drv_files(info
, driver
.info_3
) ) {
4761 free_a_printer_driver(driver
, 3);
4767 free_a_printer_driver(driver
, 3);
4772 DEBUG(5,("printer_driver_files_in_use: Completed search through ntdrivers.tdb...\n"));
4774 driver
.info_3
= info
;
4776 if ( DEBUGLEVEL
>= 20 )
4777 dump_a_printer_driver( driver
, 3 );
4782 /****************************************************************************
4783 Actually delete the driver files. Make sure that
4784 printer_driver_files_in_use() return False before calling
4786 ****************************************************************************/
4788 static BOOL
delete_driver_files( NT_PRINTER_DRIVER_INFO_LEVEL_3
*info_3
, struct current_user
*user
)
4793 connection_struct
*conn
;
4803 DEBUG(6,("delete_driver_files: deleting driver [%s] - version [%d]\n", info_3
->name
, info_3
->cversion
));
4806 * Connect to the print$ share under the same account as the
4807 * user connected to the rpc pipe. Note we must be root to
4811 null_pw
= data_blob( NULL
, 0 );
4812 fstrcpy(res_type
, "A:");
4814 conn
= make_connection_with_chdir( "print$", null_pw
, res_type
, user
->vuid
, &nt_status
);
4818 DEBUG(0,("delete_driver_files: Unable to connect\n"));
4822 if ( !CAN_WRITE(conn
) ) {
4823 DEBUG(3,("delete_driver_files: Cannot delete print driver when [print$] is read-only\n"));
4827 /* Save who we are - we are temporarily becoming the connection user. */
4829 if ( !become_user(conn
, conn
->vuid
) ) {
4830 DEBUG(0,("delete_driver_files: Can't become user!\n"));
4834 /* now delete the files; must strip the '\print$' string from
4837 if ( *info_3
->driverpath
) {
4838 if ( (s
= strchr( &info_3
->driverpath
[1], '\\' )) != NULL
) {
4840 driver_unix_convert(file
, conn
, NULL
, &bad_path
, &st
);
4841 DEBUG(10,("deleting driverfile [%s]\n", s
));
4842 unlink_internals(conn
, 0, file
, False
);
4846 if ( *info_3
->configfile
) {
4847 if ( (s
= strchr( &info_3
->configfile
[1], '\\' )) != NULL
) {
4849 driver_unix_convert(file
, conn
, NULL
, &bad_path
, &st
);
4850 DEBUG(10,("deleting configfile [%s]\n", s
));
4851 unlink_internals(conn
, 0, file
, False
);
4855 if ( *info_3
->datafile
) {
4856 if ( (s
= strchr( &info_3
->datafile
[1], '\\' )) != NULL
) {
4858 driver_unix_convert(file
, conn
, NULL
, &bad_path
, &st
);
4859 DEBUG(10,("deleting datafile [%s]\n", s
));
4860 unlink_internals(conn
, 0, file
, False
);
4864 if ( *info_3
->helpfile
) {
4865 if ( (s
= strchr( &info_3
->helpfile
[1], '\\' )) != NULL
) {
4867 driver_unix_convert(file
, conn
, NULL
, &bad_path
, &st
);
4868 DEBUG(10,("deleting helpfile [%s]\n", s
));
4869 unlink_internals(conn
, 0, file
, False
);
4873 /* check if we are done removing files */
4875 if ( info_3
->dependentfiles
) {
4876 while ( info_3
->dependentfiles
[i
][0] ) {
4879 /* bypass the "\print$" portion of the path */
4881 if ( (p
= strchr( info_3
->dependentfiles
[i
]+1, '\\' )) != NULL
) {
4883 driver_unix_convert(file
, conn
, NULL
, &bad_path
, &st
);
4884 DEBUG(10,("deleting dependent file [%s]\n", file
));
4885 unlink_internals(conn
, 0, file
, False
);
4897 /****************************************************************************
4898 Remove a printer driver from the TDB. This assumes that the the driver was
4899 previously looked up.
4900 ***************************************************************************/
4902 WERROR
delete_printer_driver( NT_PRINTER_DRIVER_INFO_LEVEL_3
*info_3
, struct current_user
*user
,
4903 uint32 version
, BOOL delete_files
)
4907 TDB_DATA kbuf
, dbuf
;
4908 NT_PRINTER_DRIVER_INFO_LEVEL ctr
;
4910 /* delete the tdb data first */
4912 arch
= get_short_archi(info_3
->environment
);
4914 return WERR_UNKNOWN_PRINTER_DRIVER
;
4916 slprintf(key
, sizeof(key
)-1, "%s%s/%d/%s", DRIVERS_PREFIX
,
4917 arch
, version
, info_3
->name
);
4919 DEBUG(5,("delete_printer_driver: key = [%s] delete_files = %s\n",
4920 key
, delete_files
? "TRUE" : "FALSE" ));
4922 ctr
.info_3
= info_3
;
4923 dump_a_printer_driver( ctr
, 3 );
4926 kbuf
.dsize
=strlen(key
)+1;
4928 /* check if the driver actually exists for this environment */
4930 dbuf
= tdb_fetch( tdb_drivers
, kbuf
);
4932 DEBUG(8,("delete_printer_driver: Driver unknown [%s]\n", key
));
4933 return WERR_UNKNOWN_PRINTER_DRIVER
;
4936 SAFE_FREE( dbuf
.dptr
);
4938 /* ok... the driver exists so the delete should return success */
4940 if (tdb_delete(tdb_drivers
, kbuf
) == -1) {
4941 DEBUG (0,("delete_printer_driver: fail to delete %s!\n", key
));
4942 return WERR_ACCESS_DENIED
;
4946 * now delete any associated files if delete_files == True
4947 * even if this part failes, we return succes because the
4948 * driver doesn not exist any more
4952 delete_driver_files( info_3
, user
);
4955 DEBUG(5,("delete_printer_driver: driver delete successful [%s]\n", key
));
4960 /****************************************************************************
4961 Store a security desc for a printer.
4962 ****************************************************************************/
4964 WERROR
nt_printing_setsec(const char *sharename
, SEC_DESC_BUF
*secdesc_ctr
)
4966 SEC_DESC_BUF
*new_secdesc_ctr
= NULL
;
4967 SEC_DESC_BUF
*old_secdesc_ctr
= NULL
;
4969 TALLOC_CTX
*mem_ctx
= NULL
;
4973 mem_ctx
= talloc_init("nt_printing_setsec");
4974 if (mem_ctx
== NULL
)
4977 /* The old owner and group sids of the security descriptor are not
4978 present when new ACEs are added or removed by changing printer
4979 permissions through NT. If they are NULL in the new security
4980 descriptor then copy them over from the old one. */
4982 if (!secdesc_ctr
->sec
->owner_sid
|| !secdesc_ctr
->sec
->grp_sid
) {
4983 DOM_SID
*owner_sid
, *group_sid
;
4984 SEC_ACL
*dacl
, *sacl
;
4985 SEC_DESC
*psd
= NULL
;
4988 if (!nt_printing_getsec(mem_ctx
, sharename
, &old_secdesc_ctr
)) {
4989 status
= WERR_NOMEM
;
4993 /* Pick out correct owner and group sids */
4995 owner_sid
= secdesc_ctr
->sec
->owner_sid
?
4996 secdesc_ctr
->sec
->owner_sid
:
4997 old_secdesc_ctr
->sec
->owner_sid
;
4999 group_sid
= secdesc_ctr
->sec
->grp_sid
?
5000 secdesc_ctr
->sec
->grp_sid
:
5001 old_secdesc_ctr
->sec
->grp_sid
;
5003 dacl
= secdesc_ctr
->sec
->dacl
?
5004 secdesc_ctr
->sec
->dacl
:
5005 old_secdesc_ctr
->sec
->dacl
;
5007 sacl
= secdesc_ctr
->sec
->sacl
?
5008 secdesc_ctr
->sec
->sacl
:
5009 old_secdesc_ctr
->sec
->sacl
;
5011 /* Make a deep copy of the security descriptor */
5013 psd
= make_sec_desc(mem_ctx
, secdesc_ctr
->sec
->revision
, secdesc_ctr
->sec
->type
,
5014 owner_sid
, group_sid
,
5020 status
= WERR_NOMEM
;
5024 new_secdesc_ctr
= make_sec_desc_buf(mem_ctx
, size
, psd
);
5027 if (!new_secdesc_ctr
) {
5028 new_secdesc_ctr
= secdesc_ctr
;
5031 /* Store the security descriptor in a tdb */
5033 prs_init(&ps
, (uint32
)sec_desc_size(new_secdesc_ctr
->sec
) +
5034 sizeof(SEC_DESC_BUF
), mem_ctx
, MARSHALL
);
5036 if (!sec_io_desc_buf("nt_printing_setsec", &new_secdesc_ctr
,
5038 status
= WERR_BADFUNC
;
5042 key
= make_printers_secdesc_tdbkey( sharename
);
5044 if (tdb_prs_store(tdb_printers
, key
, &ps
)==0) {
5047 DEBUG(1,("Failed to store secdesc for %s\n", sharename
));
5048 status
= WERR_BADFUNC
;
5051 /* Free malloc'ed memory */
5057 talloc_destroy(mem_ctx
);
5061 /****************************************************************************
5062 Construct a default security descriptor buffer for a printer.
5063 ****************************************************************************/
5065 static SEC_DESC_BUF
*construct_default_printer_sdb(TALLOC_CTX
*ctx
)
5067 SEC_ACE ace
[5]; /* max number of ace entries */
5070 SEC_ACL
*psa
= NULL
;
5071 SEC_DESC_BUF
*sdb
= NULL
;
5072 SEC_DESC
*psd
= NULL
;
5076 /* Create an ACE where Everyone is allowed to print */
5078 init_sec_access(&sa
, PRINTER_ACE_PRINT
);
5079 init_sec_ace(&ace
[i
++], &global_sid_World
, SEC_ACE_TYPE_ACCESS_ALLOWED
,
5080 sa
, SEC_ACE_FLAG_CONTAINER_INHERIT
);
5082 /* Add the domain admins group if we are a DC */
5085 DOM_SID domadmins_sid
;
5087 sid_copy(&domadmins_sid
, get_global_sam_sid());
5088 sid_append_rid(&domadmins_sid
, DOMAIN_GROUP_RID_ADMINS
);
5090 init_sec_access(&sa
, PRINTER_ACE_FULL_CONTROL
);
5091 init_sec_ace(&ace
[i
++], &domadmins_sid
,
5092 SEC_ACE_TYPE_ACCESS_ALLOWED
, sa
,
5093 SEC_ACE_FLAG_OBJECT_INHERIT
| SEC_ACE_FLAG_INHERIT_ONLY
);
5094 init_sec_ace(&ace
[i
++], &domadmins_sid
, SEC_ACE_TYPE_ACCESS_ALLOWED
,
5095 sa
, SEC_ACE_FLAG_CONTAINER_INHERIT
);
5097 else if (secrets_fetch_domain_sid(lp_workgroup(), &adm_sid
)) {
5098 sid_append_rid(&adm_sid
, DOMAIN_USER_RID_ADMIN
);
5100 init_sec_access(&sa
, PRINTER_ACE_FULL_CONTROL
);
5101 init_sec_ace(&ace
[i
++], &adm_sid
,
5102 SEC_ACE_TYPE_ACCESS_ALLOWED
, sa
,
5103 SEC_ACE_FLAG_OBJECT_INHERIT
| SEC_ACE_FLAG_INHERIT_ONLY
);
5104 init_sec_ace(&ace
[i
++], &adm_sid
, SEC_ACE_TYPE_ACCESS_ALLOWED
,
5105 sa
, SEC_ACE_FLAG_CONTAINER_INHERIT
);
5108 /* add BUILTIN\Administrators as FULL CONTROL */
5110 init_sec_access(&sa
, PRINTER_ACE_FULL_CONTROL
);
5111 init_sec_ace(&ace
[i
++], &global_sid_Builtin_Administrators
,
5112 SEC_ACE_TYPE_ACCESS_ALLOWED
, sa
,
5113 SEC_ACE_FLAG_OBJECT_INHERIT
| SEC_ACE_FLAG_INHERIT_ONLY
);
5114 init_sec_ace(&ace
[i
++], &global_sid_Builtin_Administrators
,
5115 SEC_ACE_TYPE_ACCESS_ALLOWED
,
5116 sa
, SEC_ACE_FLAG_CONTAINER_INHERIT
);
5118 /* Make the security descriptor owned by the BUILTIN\Administrators */
5120 /* The ACL revision number in rpc_secdesc.h differs from the one
5121 created by NT when setting ACE entries in printer
5122 descriptors. NT4 complains about the property being edited by a
5125 if ((psa
= make_sec_acl(ctx
, NT4_ACL_REVISION
, i
, ace
)) != NULL
) {
5126 psd
= make_sec_desc(ctx
, SEC_DESC_REVISION
, SEC_DESC_SELF_RELATIVE
,
5127 &global_sid_Builtin_Administrators
,
5128 &global_sid_Builtin_Administrators
,
5129 NULL
, psa
, &sd_size
);
5133 DEBUG(0,("construct_default_printer_sd: Failed to make SEC_DESC.\n"));
5137 sdb
= make_sec_desc_buf(ctx
, sd_size
, psd
);
5139 DEBUG(4,("construct_default_printer_sdb: size = %u.\n",
5140 (unsigned int)sd_size
));
5145 /****************************************************************************
5146 Get a security desc for a printer.
5147 ****************************************************************************/
5149 BOOL
nt_printing_getsec(TALLOC_CTX
*ctx
, const char *sharename
, SEC_DESC_BUF
**secdesc_ctr
)
5155 if (strlen(sharename
) > 2 && (temp
= strchr(sharename
+ 2, '\\'))) {
5156 sharename
= temp
+ 1;
5161 /* Fetch security descriptor from tdb */
5163 key
= make_printers_secdesc_tdbkey( sharename
);
5165 if (tdb_prs_fetch(tdb_printers
, key
, &ps
, ctx
)!=0 ||
5166 !sec_io_desc_buf("nt_printing_getsec", secdesc_ctr
, &ps
, 1)) {
5170 DEBUG(4,("using default secdesc for %s\n", sharename
));
5172 if (!(*secdesc_ctr
= construct_default_printer_sdb(ctx
))) {
5176 /* Save default security descriptor for later */
5178 prs_init(&ps
, (uint32
)sec_desc_size((*secdesc_ctr
)->sec
) +
5179 sizeof(SEC_DESC_BUF
), ctx
, MARSHALL
);
5181 if (sec_io_desc_buf("nt_printing_getsec", secdesc_ctr
, &ps
, 1)) {
5182 tdb_prs_store(tdb_printers
, key
, &ps
);
5192 /* If security descriptor is owned by S-1-1-0 and winbindd is up,
5193 this security descriptor has been created when winbindd was
5194 down. Take ownership of security descriptor. */
5196 if (sid_equal((*secdesc_ctr
)->sec
->owner_sid
, &global_sid_World
)) {
5199 /* Change sd owner to workgroup administrator */
5201 if (secrets_fetch_domain_sid(lp_workgroup(), &owner_sid
)) {
5202 SEC_DESC_BUF
*new_secdesc_ctr
= NULL
;
5203 SEC_DESC
*psd
= NULL
;
5208 sid_append_rid(&owner_sid
, DOMAIN_USER_RID_ADMIN
);
5210 psd
= make_sec_desc(ctx
, (*secdesc_ctr
)->sec
->revision
, (*secdesc_ctr
)->sec
->type
,
5212 (*secdesc_ctr
)->sec
->grp_sid
,
5213 (*secdesc_ctr
)->sec
->sacl
,
5214 (*secdesc_ctr
)->sec
->dacl
,
5221 new_secdesc_ctr
= make_sec_desc_buf(ctx
, size
, psd
);
5222 if (!new_secdesc_ctr
) {
5226 /* Swap with other one */
5228 *secdesc_ctr
= new_secdesc_ctr
;
5232 nt_printing_setsec(sharename
, *secdesc_ctr
);
5236 if (DEBUGLEVEL
>= 10) {
5237 SEC_ACL
*the_acl
= (*secdesc_ctr
)->sec
->dacl
;
5240 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5241 sharename
, the_acl
->num_aces
));
5243 for (i
= 0; i
< the_acl
->num_aces
; i
++) {
5246 sid_to_string(sid_str
, &the_acl
->ace
[i
].trustee
);
5248 DEBUG(10, ("%s %d %d 0x%08x\n", sid_str
,
5249 the_acl
->ace
[i
].type
, the_acl
->ace
[i
].flags
,
5250 the_acl
->ace
[i
].info
.mask
));
5259 1: level not implemented
5260 2: file doesn't exist
5261 3: can't allocate memory
5262 4: can't free memory
5263 5: non existant struct
5267 A printer and a printer driver are 2 different things.
5268 NT manages them separatelly, Samba does the same.
5269 Why ? Simply because it's easier and it makes sense !
5271 Now explanation: You have 3 printers behind your samba server,
5272 2 of them are the same make and model (laser A and B). But laser B
5273 has an 3000 sheet feeder and laser A doesn't such an option.
5274 Your third printer is an old dot-matrix model for the accounting :-).
5276 If the /usr/local/samba/lib directory (default dir), you will have
5277 5 files to describe all of this.
5279 3 files for the printers (1 by printer):
5282 NTprinter_accounting
5283 2 files for the drivers (1 for the laser and 1 for the dot matrix)
5284 NTdriver_printer model X
5285 NTdriver_printer model Y
5287 jfm: I should use this comment for the text file to explain
5288 same thing for the forms BTW.
5289 Je devrais mettre mes commentaires en francais, ca serait mieux :-)
5293 /* Convert generic access rights to printer object specific access rights.
5294 It turns out that NT4 security descriptors use generic access rights and
5295 NT5 the object specific ones. */
5297 void map_printer_permissions(SEC_DESC
*sd
)
5301 for (i
= 0; sd
->dacl
&& i
< sd
->dacl
->num_aces
; i
++) {
5302 se_map_generic(&sd
->dacl
->ace
[i
].info
.mask
,
5303 &printer_generic_mapping
);
5307 /****************************************************************************
5308 Check a user has permissions to perform the given operation. We use the
5309 permission constants defined in include/rpc_spoolss.h to check the various
5310 actions we perform when checking printer access.
5312 PRINTER_ACCESS_ADMINISTER:
5313 print_queue_pause, print_queue_resume, update_printer_sec,
5314 update_printer, spoolss_addprinterex_level_2,
5315 _spoolss_setprinterdata
5320 JOB_ACCESS_ADMINISTER:
5321 print_job_delete, print_job_pause, print_job_resume,
5324 Try access control in the following order (for performance reasons):
5325 1) root ans SE_PRINT_OPERATOR can do anything (easy check)
5326 2) check security descriptor (bit comparisons in memory)
5327 3) "printer admins" (may result in numerous calls to winbind)
5329 ****************************************************************************/
5330 BOOL
print_access_check(struct current_user
*user
, int snum
, int access_type
)
5332 SEC_DESC_BUF
*secdesc
= NULL
;
5333 uint32 access_granted
;
5337 TALLOC_CTX
*mem_ctx
= NULL
;
5338 SE_PRIV se_printop
= SE_PRINT_OPERATOR
;
5340 /* If user is NULL then use the current_user structure */
5343 user
= ¤t_user
;
5345 /* Always allow root or SE_PRINT_OPERATROR to do anything */
5347 if ( user
->ut
.uid
== 0 || user_has_privileges(user
->nt_user_token
, &se_printop
) ) {
5351 /* Get printer name */
5353 pname
= PRINTERNAME(snum
);
5355 if (!pname
|| !*pname
) {
5360 /* Get printer security descriptor */
5362 if(!(mem_ctx
= talloc_init("print_access_check"))) {
5367 if (!nt_printing_getsec(mem_ctx
, pname
, &secdesc
)) {
5368 talloc_destroy(mem_ctx
);
5373 if (access_type
== JOB_ACCESS_ADMINISTER
) {
5374 SEC_DESC_BUF
*parent_secdesc
= secdesc
;
5376 /* Create a child security descriptor to check permissions
5377 against. This is because print jobs are child objects
5378 objects of a printer. */
5380 secdesc
= se_create_child_secdesc(mem_ctx
, parent_secdesc
->sec
, False
);
5383 talloc_destroy(mem_ctx
);
5388 /* Now this is the bit that really confuses me. The access
5389 type needs to be changed from JOB_ACCESS_ADMINISTER to
5390 PRINTER_ACCESS_ADMINISTER for this to work. Something
5391 to do with the child (job) object becoming like a
5394 access_type
= PRINTER_ACCESS_ADMINISTER
;
5399 map_printer_permissions(secdesc
->sec
);
5401 result
= se_access_check(secdesc
->sec
, user
->nt_user_token
, access_type
,
5402 &access_granted
, &status
);
5404 DEBUG(4, ("access check was %s\n", result
? "SUCCESS" : "FAILURE"));
5406 /* see if we need to try the printer admin list */
5408 if ((access_granted
== 0) &&
5409 (token_contains_name_in_list(uidtoname(user
->ut
.uid
), NULL
,
5410 user
->nt_user_token
,
5411 lp_printer_admin(snum
)))) {
5412 talloc_destroy(mem_ctx
);
5416 talloc_destroy(mem_ctx
);
5425 /****************************************************************************
5426 Check the time parameters allow a print operation.
5427 *****************************************************************************/
5429 BOOL
print_time_access_check(int snum
)
5431 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
5433 time_t now
= time(NULL
);
5437 if (!W_ERROR_IS_OK(get_a_printer(NULL
, &printer
, 2, lp_servicename(snum
))))
5440 if (printer
->info_2
->starttime
== 0 && printer
->info_2
->untiltime
== 0)
5444 mins
= (uint32
)t
->tm_hour
*60 + (uint32
)t
->tm_min
;
5446 if (mins
>= printer
->info_2
->starttime
&& mins
<= printer
->info_2
->untiltime
)
5449 free_a_printer(&printer
, 2);
5457 /****************************************************************************
5458 Fill in the servername sent in the _spoolss_open_printer_ex() call
5459 ****************************************************************************/
5461 char* get_server_name( Printer_entry
*printer
)
5463 return printer
->servername
;