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"
24 #include "printer_list.h"
26 #define PL_DB_NAME() lock_path("printer_list.tdb")
27 #define PL_KEY_PREFIX "PRINTERLIST/PRN/"
28 #define PL_KEY_FORMAT PL_KEY_PREFIX"%s"
29 #define PL_TIMESTAMP_KEY "PRINTERLIST/GLOBAL/LAST_REFRESH"
30 #define PL_DATA_FORMAT "ddPPP"
31 #define PL_TSTAMP_FORMAT "dd"
33 static struct db_context
*get_printer_list_db(void)
35 static struct db_context
*db
;
40 db
= db_open(NULL
, PL_DB_NAME(), 0,
41 TDB_DEFAULT
|TDB_CLEAR_IF_FIRST
|TDB_INCOMPATIBLE_HASH
,
42 O_RDWR
|O_CREAT
, 0644);
46 bool printer_list_parent_init(void)
48 struct db_context
*db
;
51 * Open the tdb in the parent process (smbd) so that our
52 * CLEAR_IF_FIRST optimization in tdb_reopen_all can properly
56 db
= get_printer_list_db();
58 DEBUG(1, ("could not open Printer List Database: %s\n",
65 NTSTATUS
printer_list_get_printer(TALLOC_CTX
*mem_ctx
,
68 const char **location
,
71 struct db_context
*db
;
74 uint32_t time_h
, time_l
;
81 db
= get_printer_list_db();
83 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
86 key
= talloc_asprintf(mem_ctx
, PL_KEY_FORMAT
, name
);
88 DEBUG(0, ("Failed to allocate key name!\n"));
89 return NT_STATUS_NO_MEMORY
;
92 data
= dbwrap_fetch_bystring_upper(db
, key
, key
);
93 if (data
.dptr
== NULL
) {
94 DEBUG(1, ("Failed to fetch record!\n"));
95 status
= NT_STATUS_NOT_FOUND
;
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 data
= dbwrap_fetch_bystring(db
, talloc_tos(), PL_TIMESTAMP_KEY
);
219 if (data
.dptr
== NULL
) {
220 DEBUG(1, ("Failed to fetch record!\n"));
221 status
= NT_STATUS_NOT_FOUND
;
225 ret
= tdb_unpack(data
.dptr
, data
.dsize
,
226 PL_TSTAMP_FORMAT
, &time_h
, &time_l
);
228 DEBUG(1, ("Failed to un pack printer data"));
229 status
= NT_STATUS_INTERNAL_DB_CORRUPTION
;
233 *last_refresh
= (time_t)(((uint64_t)time_h
<< 32) + time_l
);
234 status
= NT_STATUS_OK
;
240 NTSTATUS
printer_list_mark_reload(void)
242 struct db_context
*db
;
244 uint32_t time_h
, time_l
;
245 time_t now
= time_mono(NULL
);
249 db
= get_printer_list_db();
251 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
254 time_l
= ((uint64_t)now
) & 0xFFFFFFFFL
;
255 time_h
= ((uint64_t)now
) >> 32;
257 len
= tdb_pack(NULL
, 0, PL_TSTAMP_FORMAT
, time_h
, time_l
);
259 data
.dptr
= talloc_array(talloc_tos(), uint8_t, len
);
261 DEBUG(0, ("Failed to allocate tdb data buffer!\n"));
262 status
= NT_STATUS_NO_MEMORY
;
267 len
= tdb_pack(data
.dptr
, data
.dsize
,
268 PL_TSTAMP_FORMAT
, time_h
, time_l
);
270 status
= dbwrap_store_bystring(db
, PL_TIMESTAMP_KEY
,
274 TALLOC_FREE(data
.dptr
);
278 typedef int (printer_list_trv_fn_t
)(struct db_record
*, void *);
280 static NTSTATUS
printer_list_traverse(printer_list_trv_fn_t
*fn
,
283 struct db_context
*db
;
286 db
= get_printer_list_db();
288 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
291 ret
= db
->traverse(db
, fn
, private_data
);
293 return NT_STATUS_UNSUCCESSFUL
;
299 struct printer_list_clean_state
{
304 static int printer_list_clean_fn(struct db_record
*rec
, void *private_data
)
306 struct printer_list_clean_state
*state
=
307 (struct printer_list_clean_state
*)private_data
;
308 uint32_t time_h
, time_l
;
315 /* skip anything that does not contain PL_DATA_FORMAT data */
316 if (strncmp((char *)rec
->key
.dptr
,
317 PL_KEY_PREFIX
, sizeof(PL_KEY_PREFIX
)-1)) {
321 ret
= tdb_unpack(rec
->value
.dptr
, rec
->value
.dsize
,
322 PL_DATA_FORMAT
, &time_h
, &time_l
, &name
, &comment
,
325 DEBUG(1, ("Failed to un pack printer data"));
326 state
->status
= NT_STATUS_INTERNAL_DB_CORRUPTION
;
334 refresh
= (time_t)(((uint64_t)time_h
<< 32) + time_l
);
336 if (refresh
< state
->last_refresh
) {
337 state
->status
= rec
->delete_rec(rec
);
338 if (!NT_STATUS_IS_OK(state
->status
)) {
346 NTSTATUS
printer_list_clean_old(void)
348 struct printer_list_clean_state state
;
351 status
= printer_list_get_last_refresh(&state
.last_refresh
);
352 if (!NT_STATUS_IS_OK(status
)) {
356 state
.status
= NT_STATUS_OK
;
358 status
= printer_list_traverse(printer_list_clean_fn
, &state
);
359 if (NT_STATUS_EQUAL(status
, NT_STATUS_UNSUCCESSFUL
) &&
360 !NT_STATUS_IS_OK(state
.status
)) {
361 status
= state
.status
;
367 struct printer_list_exec_state
{
368 void (*fn
)(const char *, const char *, const char *, void *);
373 static int printer_list_exec_fn(struct db_record
*rec
, void *private_data
)
375 struct printer_list_exec_state
*state
=
376 (struct printer_list_exec_state
*)private_data
;
377 uint32_t time_h
, time_l
;
383 /* always skip PL_TIMESTAMP_KEY key */
384 if (strequal((const char *)rec
->key
.dptr
, PL_TIMESTAMP_KEY
)) {
388 ret
= tdb_unpack(rec
->value
.dptr
, rec
->value
.dsize
,
389 PL_DATA_FORMAT
, &time_h
, &time_l
, &name
, &comment
,
392 DEBUG(1, ("Failed to un pack printer data"));
393 state
->status
= NT_STATUS_INTERNAL_DB_CORRUPTION
;
397 state
->fn(name
, comment
, location
, state
->private_data
);
405 NTSTATUS
printer_list_run_fn(void (*fn
)(const char *, const char *, const char *, void *),
408 struct printer_list_exec_state state
;
412 state
.private_data
= private_data
;
413 state
.status
= NT_STATUS_OK
;
415 status
= printer_list_traverse(printer_list_exec_fn
, &state
);
416 if (NT_STATUS_EQUAL(status
, NT_STATUS_UNSUCCESSFUL
) &&
417 !NT_STATUS_IS_OK(state
.status
)) {
418 status
= state
.status
;