source: vendor/3.6.23/source3/libsmb/libsmb_printjob.c

Last change on this file was 740, checked in by Silvan Scherrer, 13 years ago

Samba Server: update vendor to 3.6.0
File size: 8.7 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 "libsmb/libsmb.h"
27#include "libsmbclient.h"
28#include "libsmb_internal.h"
29
30
31/*
32 * Open a print file to be written to by other calls
33 */
34
35SMBCFILE *
36SMBC_open_print_job_ctx(SMBCCTX *context,
37 const char *fname)
38{
39 char *server = NULL;
40 char *share = NULL;
41 char *user = NULL;
42 char *password = NULL;
43 char *path = NULL;
44 TALLOC_CTX *frame = talloc_stackframe();
45
46 if (!context || !context->internal->initialized) {
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 errno = EINVAL;
105 TALLOC_FREE(frame);
106 return -1;
107 }
108
109 if (!fname && !printq) {
110 errno = EINVAL;
111 TALLOC_FREE(frame);
112 return -1;
113 }
114
115 /* Try to open the file for reading ... */
116
117 if ((long)(fid1 = smbc_getFunctionOpen(c_file)(c_file, fname,
118 O_RDONLY, 0666)) < 0) {
119 DEBUG(3, ("Error, fname=%s, errno=%i\n", fname, errno));
120 TALLOC_FREE(frame);
121 return -1; /* smbc_open sets errno */
122 }
123
124 /* Now, try to open the printer file for writing */
125
126 if ((long)(fid2 = smbc_getFunctionOpenPrintJob(c_print)(c_print,
127 printq)) < 0) {
128 saverr = errno; /* Save errno */
129 smbc_getFunctionClose(c_file)(c_file, fid1);
130 errno = saverr;
131 TALLOC_FREE(frame);
132 return -1;
133 }
134
135 while ((bytes = smbc_getFunctionRead(c_file)(c_file, fid1,
136 buf, sizeof(buf))) > 0) {
137 tot_bytes += bytes;
138
139 if ((smbc_getFunctionWrite(c_print)(c_print, fid2,
140 buf, bytes)) < 0) {
141 saverr = errno;
142 smbc_getFunctionClose(c_file)(c_file, fid1);
143 smbc_getFunctionClose(c_print)(c_print, fid2);
144 errno = saverr;
145 }
146 }
147
148 saverr = errno;
149
150 smbc_getFunctionClose(c_file)(c_file, fid1);
151 smbc_getFunctionClose(c_print)(c_print, fid2);
152
153 if (bytes < 0) {
154 errno = saverr;
155 TALLOC_FREE(frame);
156 return -1;
157 }
158
159 TALLOC_FREE(frame);
160 return tot_bytes;
161}
162
163/*
164 * Routine to list print jobs on a printer share ...
165 */
166
167int
168SMBC_list_print_jobs_ctx(SMBCCTX *context,
169 const char *fname,
170 smbc_list_print_job_fn fn)
171{
172 SMBCSRV *srv = NULL;
173 char *server = NULL;
174 char *share = NULL;
175 char *user = NULL;
176 char *password = NULL;
177 char *workgroup = NULL;
178 char *path = NULL;
179 TALLOC_CTX *frame = talloc_stackframe();
180
181 if (!context || !context->internal->initialized) {
182 errno = EINVAL;
183 TALLOC_FREE(frame);
184 return -1;
185 }
186
187 if (!fname) {
188 errno = EINVAL;
189 TALLOC_FREE(frame);
190 return -1;
191 }
192
193 DEBUG(4, ("smbc_list_print_jobs(%s)\n", fname));
194
195 if (SMBC_parse_path(frame,
196 context,
197 fname,
198 &workgroup,
199 &server,
200 &share,
201 &path,
202 &user,
203 &password,
204 NULL)) {
205 errno = EINVAL;
206 TALLOC_FREE(frame);
207 return -1;
208 }
209
210 if (!user || user[0] == (char)0) {
211 user = talloc_strdup(frame, smbc_getUser(context));
212 if (!user) {
213 errno = ENOMEM;
214 TALLOC_FREE(frame);
215 return -1;
216 }
217 }
218
219 srv = SMBC_server(frame, context, True,
220 server, share, &workgroup, &user, &password);
221
222 if (!srv) {
223 TALLOC_FREE(frame);
224 return -1; /* errno set by SMBC_server */
225 }
226
227 if (cli_print_queue(srv->cli,
228 (void (*)(struct print_job_info *))fn) < 0) {
229 errno = SMBC_errno(context, srv->cli);
230 TALLOC_FREE(frame);
231 return -1;
232 }
233
234 TALLOC_FREE(frame);
235 return 0;
236}
237
238/*
239 * Delete a print job from a remote printer share
240 */
241
242int
243SMBC_unlink_print_job_ctx(SMBCCTX *context,
244 const char *fname,
245 int id)
246{
247 SMBCSRV *srv = NULL;
248 char *server = NULL;
249 char *share = NULL;
250 char *user = NULL;
251 char *password = NULL;
252 char *workgroup = NULL;
253 char *path = NULL;
254 int err;
255 TALLOC_CTX *frame = talloc_stackframe();
256
257 if (!context || !context->internal->initialized) {
258 errno = EINVAL;
259 TALLOC_FREE(frame);
260 return -1;
261 }
262
263 if (!fname) {
264 errno = EINVAL;
265 TALLOC_FREE(frame);
266 return -1;
267 }
268
269 DEBUG(4, ("smbc_unlink_print_job(%s)\n", fname));
270
271 if (SMBC_parse_path(frame,
272 context,
273 fname,
274 &workgroup,
275 &server,
276 &share,
277 &path,
278 &user,
279 &password,
280 NULL)) {
281 errno = EINVAL;
282 TALLOC_FREE(frame);
283 return -1;
284 }
285
286 if (!user || user[0] == (char)0) {
287 user = talloc_strdup(frame, smbc_getUser(context));
288 if (!user) {
289 errno = ENOMEM;
290 TALLOC_FREE(frame);
291 return -1;
292 }
293 }
294
295 srv = SMBC_server(frame, context, True,
296 server, share, &workgroup, &user, &password);
297
298 if (!srv) {
299 TALLOC_FREE(frame);
300 return -1; /* errno set by SMBC_server */
301 }
302
303 if ((err = cli_printjob_del(srv->cli, id)) != 0) {
304 if (err < 0)
305 errno = SMBC_errno(context, srv->cli);
306 else if (err == ERRnosuchprintjob)
307 errno = EINVAL;
308 TALLOC_FREE(frame);
309 return -1;
310 }
311
312 TALLOC_FREE(frame);
313 return 0;
314}
315
Note: See TracBrowser for help on using the repository browser.