source: branches/samba-3.2.x/source/libsmb/libsmb_printjob.c

Last change on this file was 133, checked in by Paul Smedley, 17 years ago

Update trunk to 3.2.0pre3
File size: 9.0 KB
Line 
1/*
2 Unix SMB/Netbios implementation.
3 SMB client library implementation
4 Copyright (C) Andrew Tridgell 1998
5 Copyright (C) Richard Sharpe 2000, 2002
6 Copyright (C) John Terpstra 2000
7 Copyright (C) Tom Jansen (Ninja ISD) 2002
8 Copyright (C) Derrell Lipman 2003-2008
9 Copyright (C) Jeremy Allison 2007, 2008
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>.
23*/
24
25#include "includes.h"
26#include "libsmbclient.h"
27#include "libsmb_internal.h"
28
29
30/*
31 * Open a print file to be written to by other calls
32 */
33
34SMBCFILE *
35SMBC_open_print_job_ctx(SMBCCTX *context,
36 const char *fname)
37{
38 char *server = NULL;
39 char *share = NULL;
40 char *user = NULL;
41 char *password = NULL;
42 char *path = NULL;
43 TALLOC_CTX *frame = talloc_stackframe();
44
45 if (!context || !context->internal->initialized) {
46
47 errno = EINVAL;
48 TALLOC_FREE(frame);
49 return NULL;
50 }
51
52 if (!fname) {
53 errno = EINVAL;
54 TALLOC_FREE(frame);
55 return NULL;
56 }
57
58 DEBUG(4, ("SMBC_open_print_job_ctx(%s)\n", fname));
59
60 if (SMBC_parse_path(frame,
61 context,
62 fname,
63 NULL,
64 &server,
65 &share,
66 &path,
67 &user,
68 &password,
69 NULL)) {
70 errno = EINVAL;
71 TALLOC_FREE(frame);
72 return NULL;
73 }
74
75 /* What if the path is empty, or the file exists? */
76
77 TALLOC_FREE(frame);
78 return smbc_getFunctionOpen(context)(context, fname, O_WRONLY, 666);
79}
80
81/*
82 * Routine to print a file on a remote server ...
83 *
84 * We open the file, which we assume to be on a remote server, and then
85 * copy it to a print file on the share specified by printq.
86 */
87
88int
89SMBC_print_file_ctx(SMBCCTX *c_file,
90 const char *fname,
91 SMBCCTX *c_print,
92 const char *printq)
93{
94 SMBCFILE *fid1;
95 SMBCFILE *fid2;
96 int bytes;
97 int saverr;
98 int tot_bytes = 0;
99 char buf[4096];
100 TALLOC_CTX *frame = talloc_stackframe();
101
102 if (!c_file || !c_file->internal->initialized ||
103 !c_print || !c_print->internal->initialized) {
104
105 errno = EINVAL;
106 TALLOC_FREE(frame);
107 return -1;
108
109 }
110
111 if (!fname && !printq) {
112
113 errno = EINVAL;
114 TALLOC_FREE(frame);
115 return -1;
116
117 }
118
119 /* Try to open the file for reading ... */
120
121 if ((long)(fid1 = smbc_getFunctionOpen(c_file)(c_file, fname,
122 O_RDONLY, 0666)) < 0) {
123 DEBUG(3, ("Error, fname=%s, errno=%i\n", fname, errno));
124 TALLOC_FREE(frame);
125 return -1; /* smbc_open sets errno */
126 }
127
128 /* Now, try to open the printer file for writing */
129
130 if ((long)(fid2 = smbc_getFunctionOpenPrintJob(c_print)(c_print,
131 printq)) < 0) {
132
133 saverr = errno; /* Save errno */
134 smbc_getFunctionClose(c_file)(c_file, fid1);
135 errno = saverr;
136 TALLOC_FREE(frame);
137 return -1;
138
139 }
140
141 while ((bytes = smbc_getFunctionRead(c_file)(c_file, fid1,
142 buf, sizeof(buf))) > 0) {
143
144 tot_bytes += bytes;
145
146 if ((smbc_getFunctionWrite(c_print)(c_print, fid2,
147 buf, bytes)) < 0) {
148
149 saverr = errno;
150 smbc_getFunctionClose(c_file)(c_file, fid1);
151 smbc_getFunctionClose(c_print)(c_print, fid2);
152 errno = saverr;
153
154 }
155
156 }
157
158 saverr = errno;
159
160 smbc_getFunctionClose(c_file)(c_file, fid1);
161 smbc_getFunctionClose(c_print)(c_print, fid2);
162
163 if (bytes < 0) {
164
165 errno = saverr;
166 TALLOC_FREE(frame);
167 return -1;
168
169 }
170
171 TALLOC_FREE(frame);
172 return tot_bytes;
173
174}
175
176/*
177 * Routine to list print jobs on a printer share ...
178 */
179
180int
181SMBC_list_print_jobs_ctx(SMBCCTX *context,
182 const char *fname,
183 smbc_list_print_job_fn fn)
184{
185 SMBCSRV *srv = NULL;
186 char *server = NULL;
187 char *share = NULL;
188 char *user = NULL;
189 char *password = NULL;
190 char *workgroup = NULL;
191 char *path = NULL;
192 TALLOC_CTX *frame = talloc_stackframe();
193
194 if (!context || !context->internal->initialized) {
195
196 errno = EINVAL;
197 TALLOC_FREE(frame);
198 return -1;
199 }
200
201 if (!fname) {
202 errno = EINVAL;
203 TALLOC_FREE(frame);
204 return -1;
205 }
206
207 DEBUG(4, ("smbc_list_print_jobs(%s)\n", fname));
208
209 if (SMBC_parse_path(frame,
210 context,
211 fname,
212 &workgroup,
213 &server,
214 &share,
215 &path,
216 &user,
217 &password,
218 NULL)) {
219 errno = EINVAL;
220 TALLOC_FREE(frame);
221 return -1;
222 }
223
224 if (!user || user[0] == (char)0) {
225 user = talloc_strdup(frame, smbc_getUser(context));
226 if (!user) {
227 errno = ENOMEM;
228 TALLOC_FREE(frame);
229 return -1;
230 }
231 }
232
233 srv = SMBC_server(frame, context, True,
234 server, share, &workgroup, &user, &password);
235
236 if (!srv) {
237 TALLOC_FREE(frame);
238 return -1; /* errno set by SMBC_server */
239 }
240
241 if (cli_print_queue(srv->cli,
242 (void (*)(struct print_job_info *))fn) < 0) {
243 errno = SMBC_errno(context, srv->cli);
244 TALLOC_FREE(frame);
245 return -1;
246 }
247
248 TALLOC_FREE(frame);
249 return 0;
250
251}
252
253/*
254 * Delete a print job from a remote printer share
255 */
256
257int
258SMBC_unlink_print_job_ctx(SMBCCTX *context,
259 const char *fname,
260 int id)
261{
262 SMBCSRV *srv = NULL;
263 char *server = NULL;
264 char *share = NULL;
265 char *user = NULL;
266 char *password = NULL;
267 char *workgroup = NULL;
268 char *path = NULL;
269 int err;
270 TALLOC_CTX *frame = talloc_stackframe();
271
272 if (!context || !context->internal->initialized) {
273
274 errno = EINVAL;
275 TALLOC_FREE(frame);
276 return -1;
277 }
278
279 if (!fname) {
280 errno = EINVAL;
281 TALLOC_FREE(frame);
282 return -1;
283 }
284
285 DEBUG(4, ("smbc_unlink_print_job(%s)\n", fname));
286
287 if (SMBC_parse_path(frame,
288 context,
289 fname,
290 &workgroup,
291 &server,
292 &share,
293 &path,
294 &user,
295 &password,
296 NULL)) {
297 errno = EINVAL;
298 TALLOC_FREE(frame);
299 return -1;
300 }
301
302 if (!user || user[0] == (char)0) {
303 user = talloc_strdup(frame, smbc_getUser(context));
304 if (!user) {
305 errno = ENOMEM;
306 TALLOC_FREE(frame);
307 return -1;
308 }
309 }
310
311 srv = SMBC_server(frame, context, True,
312 server, share, &workgroup, &user, &password);
313
314 if (!srv) {
315
316 TALLOC_FREE(frame);
317 return -1; /* errno set by SMBC_server */
318
319 }
320
321 if ((err = cli_printjob_del(srv->cli, id)) != 0) {
322
323 if (err < 0)
324 errno = SMBC_errno(context, srv->cli);
325 else if (err == ERRnosuchprintjob)
326 errno = EINVAL;
327 TALLOC_FREE(frame);
328 return -1;
329
330 }
331
332 TALLOC_FREE(frame);
333 return 0;
334
335}
336
Note: See TracBrowser for help on using the repository browser.