2 Unix SMB/CIFS implementation.
3 Share Database of available printers.
4 Copyright (C) Simo Sorce 2010
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 #include "system/filesys.h"
22 #include "dbwrap/dbwrap.h"
23 #include "dbwrap/dbwrap_open.h"
25 #include "printer_list.h"
27 #define PL_DB_NAME() lock_path("printer_list.tdb")
28 #define PL_KEY_PREFIX "PRINTERLIST/PRN/"
29 #define PL_KEY_FORMAT PL_KEY_PREFIX"%s"
30 #define PL_TIMESTAMP_KEY "PRINTERLIST/GLOBAL/LAST_REFRESH"
31 #define PL_DATA_FORMAT "ddPPP"
32 #define PL_TSTAMP_FORMAT "dd"
34 static struct db_context
*get_printer_list_db(void)
36 static struct db_context
*db
;
41 db
= db_open(NULL
, PL_DB_NAME(), 0,
42 TDB_DEFAULT
|TDB_CLEAR_IF_FIRST
|TDB_INCOMPATIBLE_HASH
,
43 O_RDWR
|O_CREAT
, 0644, DBWRAP_LOCK_ORDER_1
);
47 bool printer_list_parent_init(void)
49 struct db_context
*db
;
52 * Open the tdb in the parent process (smbd) so that our
53 * CLEAR_IF_FIRST optimization in tdb_reopen_all can properly
57 db
= get_printer_list_db();
59 DEBUG(1, ("could not open Printer List Database: %s\n",
66 NTSTATUS
printer_list_get_printer(TALLOC_CTX
*mem_ctx
,
69 const char **location
,
72 struct db_context
*db
;
75 uint32_t time_h
, time_l
;
82 db
= get_printer_list_db();
84 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
87 key
= talloc_asprintf(mem_ctx
, PL_KEY_FORMAT
, name
);
89 DEBUG(0, ("Failed to allocate key name!\n"));
90 return NT_STATUS_NO_MEMORY
;
93 status
= dbwrap_fetch_bystring_upper(db
, key
, key
, &data
);
94 if (!NT_STATUS_IS_OK(status
)) {
95 DEBUG(1, ("Failed to fetch record!\n"));
99 ret
= tdb_unpack(data
.dptr
, data
.dsize
,
101 &time_h
, &time_l
, &nstr
, &cstr
, &lstr
);
103 DEBUG(1, ("Failed to un pack printer data"));
104 status
= NT_STATUS_INTERNAL_DB_CORRUPTION
;
109 *last_refresh
= (time_t)(((uint64_t)time_h
<< 32) + time_l
);
113 *comment
= talloc_strdup(mem_ctx
, cstr
);
115 DEBUG(1, ("Failed to strdup comment!\n"));
116 status
= NT_STATUS_NO_MEMORY
;
122 *location
= talloc_strdup(mem_ctx
, lstr
);
123 if (*location
== NULL
) {
124 DEBUG(1, ("Failed to strdup location!\n"));
125 status
= NT_STATUS_NO_MEMORY
;
130 status
= NT_STATUS_OK
;
139 NTSTATUS
printer_list_set_printer(TALLOC_CTX
*mem_ctx
,
142 const char *location
,
145 struct db_context
*db
;
149 uint32_t time_h
, time_l
;
150 const char *str
= NULL
;
151 const char *str2
= NULL
;
155 db
= get_printer_list_db();
157 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
160 key
= talloc_asprintf(mem_ctx
, PL_KEY_FORMAT
, name
);
162 DEBUG(0, ("Failed to allocate key name!\n"));
163 return NT_STATUS_NO_MEMORY
;
179 time_64
= last_refresh
;
180 time_l
= time_64
& 0xFFFFFFFFL
;
181 time_h
= time_64
>> 32;
183 len
= tdb_pack(NULL
, 0, PL_DATA_FORMAT
, time_h
, time_l
, name
, str
, str2
);
185 data
.dptr
= talloc_array(key
, uint8_t, len
);
187 DEBUG(0, ("Failed to allocate tdb data buffer!\n"));
188 status
= NT_STATUS_NO_MEMORY
;
193 len
= tdb_pack(data
.dptr
, data
.dsize
,
194 PL_DATA_FORMAT
, time_h
, time_l
, name
, str
, str2
);
196 status
= dbwrap_store_bystring_upper(db
, key
, data
, TDB_REPLACE
);
203 NTSTATUS
printer_list_get_last_refresh(time_t *last_refresh
)
205 struct db_context
*db
;
207 uint32_t time_h
, time_l
;
211 db
= get_printer_list_db();
213 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
218 status
= dbwrap_fetch_bystring(db
, talloc_tos(), PL_TIMESTAMP_KEY
, &data
);
219 if (!NT_STATUS_IS_OK(status
)) {
220 DEBUG(1, ("Failed to fetch record!\n"));
224 ret
= tdb_unpack(data
.dptr
, data
.dsize
,
225 PL_TSTAMP_FORMAT
, &time_h
, &time_l
);
227 DEBUG(1, ("Failed to un pack printer data"));
228 status
= NT_STATUS_INTERNAL_DB_CORRUPTION
;
232 *last_refresh
= (time_t)(((uint64_t)time_h
<< 32) + time_l
);
233 status
= NT_STATUS_OK
;
239 NTSTATUS
printer_list_mark_reload(void)
241 struct db_context
*db
;
243 uint32_t time_h
, time_l
;
244 time_t now
= time_mono(NULL
);
248 db
= get_printer_list_db();
250 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
253 time_l
= ((uint64_t)now
) & 0xFFFFFFFFL
;
254 time_h
= ((uint64_t)now
) >> 32;
256 len
= tdb_pack(NULL
, 0, PL_TSTAMP_FORMAT
, time_h
, time_l
);
258 data
.dptr
= talloc_array(talloc_tos(), uint8_t, len
);
260 DEBUG(0, ("Failed to allocate tdb data buffer!\n"));
261 status
= NT_STATUS_NO_MEMORY
;
266 len
= tdb_pack(data
.dptr
, data
.dsize
,
267 PL_TSTAMP_FORMAT
, time_h
, time_l
);
269 status
= dbwrap_store_bystring(db
, PL_TIMESTAMP_KEY
,
273 TALLOC_FREE(data
.dptr
);
277 typedef int (printer_list_trv_fn_t
)(struct db_record
*, void *);
279 static NTSTATUS
printer_list_traverse(printer_list_trv_fn_t
*fn
,
282 struct db_context
*db
;
285 db
= get_printer_list_db();
287 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
290 status
= dbwrap_traverse(db
, fn
, private_data
, NULL
);
295 struct printer_list_clean_state
{
300 static int printer_list_clean_fn(struct db_record
*rec
, void *private_data
)
302 struct printer_list_clean_state
*state
=
303 (struct printer_list_clean_state
*)private_data
;
304 uint32_t time_h
, time_l
;
313 key
= dbwrap_record_get_key(rec
);
315 /* skip anything that does not contain PL_DATA_FORMAT data */
316 if (strncmp((char *)key
.dptr
,
317 PL_KEY_PREFIX
, sizeof(PL_KEY_PREFIX
)-1)) {
321 value
= dbwrap_record_get_value(rec
);
323 ret
= tdb_unpack(value
.dptr
, value
.dsize
,
324 PL_DATA_FORMAT
, &time_h
, &time_l
, &name
, &comment
,
327 DEBUG(1, ("Failed to un pack printer data"));
328 state
->status
= NT_STATUS_INTERNAL_DB_CORRUPTION
;
336 refresh
= (time_t)(((uint64_t)time_h
<< 32) + time_l
);
338 if (refresh
< state
->last_refresh
) {
339 state
->status
= dbwrap_record_delete(rec
);
340 if (!NT_STATUS_IS_OK(state
->status
)) {
348 NTSTATUS
printer_list_clean_old(void)
350 struct printer_list_clean_state state
;
353 status
= printer_list_get_last_refresh(&state
.last_refresh
);
354 if (!NT_STATUS_IS_OK(status
)) {
358 state
.status
= NT_STATUS_OK
;
360 status
= printer_list_traverse(printer_list_clean_fn
, &state
);
361 if (NT_STATUS_EQUAL(status
, NT_STATUS_UNSUCCESSFUL
) &&
362 !NT_STATUS_IS_OK(state
.status
)) {
363 status
= state
.status
;
369 struct printer_list_exec_state
{
370 void (*fn
)(const char *, const char *, const char *, void *);
375 static int printer_list_exec_fn(struct db_record
*rec
, void *private_data
)
377 struct printer_list_exec_state
*state
=
378 (struct printer_list_exec_state
*)private_data
;
379 uint32_t time_h
, time_l
;
387 key
= dbwrap_record_get_key(rec
);
389 /* always skip PL_TIMESTAMP_KEY key */
390 if (strequal((const char *)key
.dptr
, PL_TIMESTAMP_KEY
)) {
394 value
= dbwrap_record_get_value(rec
);
396 ret
= tdb_unpack(value
.dptr
, value
.dsize
,
397 PL_DATA_FORMAT
, &time_h
, &time_l
, &name
, &comment
,
400 DEBUG(1, ("Failed to un pack printer data"));
401 state
->status
= NT_STATUS_INTERNAL_DB_CORRUPTION
;
405 state
->fn(name
, comment
, location
, state
->private_data
);
413 NTSTATUS
printer_list_run_fn(void (*fn
)(const char *, const char *, const char *, void *),
416 struct printer_list_exec_state state
;
420 state
.private_data
= private_data
;
421 state
.status
= NT_STATUS_OK
;
423 status
= printer_list_traverse(printer_list_exec_fn
, &state
);
424 if (NT_STATUS_EQUAL(status
, NT_STATUS_UNSUCCESSFUL
) &&
425 !NT_STATUS_IS_OK(state
.status
)) {
426 status
= state
.status
;