Fix more asprintf warnings and some error path errors.
[jra/samba/.git] / source3 / printing / print_generic.c
1 /* 
2    Unix SMB/CIFS implementation.
3    printing command routines
4    Copyright (C) Andrew Tridgell 1992-2000
5    
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.
10    
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.
15    
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/>.
18 */
19
20 #include "includes.h"
21 #include "printing.h"
22
23 extern struct current_user current_user;
24 extern userdom_struct current_user_info;
25
26 /****************************************************************************
27  Run a given print command
28  a null terminated list of value/substitute pairs is provided
29  for local substitution strings
30 ****************************************************************************/
31 static int print_run_command(int snum, const char* printername, bool do_sub,
32                              const char *command, int *outfd, ...)
33 {
34         char *syscmd;
35         char *arg;
36         int ret;
37         TALLOC_CTX *ctx = talloc_tos();
38         va_list ap;
39         va_start(ap, outfd);
40
41         /* check for a valid system printername and valid command to run */
42
43         if ( !printername || !*printername ) {
44                 va_end(ap);
45                 return -1;
46         }
47
48         if (!command || !*command) {
49                 va_end(ap);
50                 return -1;
51         }
52
53         syscmd = talloc_strdup(ctx, command);
54         if (!syscmd) {
55                 va_end(ap);
56                 return -1;
57         }
58
59         while ((arg = va_arg(ap, char *))) {
60                 char *value = va_arg(ap,char *);
61                 syscmd = talloc_string_sub(ctx, syscmd, arg, value);
62                 if (!syscmd) {
63                         va_end(ap);
64                         return -1;
65                 }
66         }
67         va_end(ap);
68
69         syscmd = talloc_string_sub(ctx, syscmd, "%p", printername);
70         if (!syscmd) {
71                 return -1;
72         }
73
74         if (do_sub && snum != -1) {
75                 syscmd = talloc_sub_advanced(ctx,
76                                 lp_servicename(snum),
77                                 current_user_info.unix_name,
78                                 "",
79                                 current_user.ut.gid,
80                                 get_current_username(),
81                                 current_user_info.domain,
82                                 syscmd);
83                 if (!syscmd) {
84                         return -1;
85                 }
86         }
87
88         ret = smbrun_no_sanitize(syscmd,outfd);
89
90         DEBUG(3,("Running the command `%s' gave %d\n",syscmd,ret));
91
92         return ret;
93 }
94
95
96 /****************************************************************************
97 delete a print job
98 ****************************************************************************/
99 static int generic_job_delete( const char *sharename, const char *lprm_command, struct printjob *pjob)
100 {
101         fstring jobstr;
102
103         /* need to delete the spooled entry */
104         slprintf(jobstr, sizeof(jobstr)-1, "%d", pjob->sysjob);
105         return print_run_command( -1, sharename, False, lprm_command, NULL,
106                    "%j", jobstr,
107                    "%T", http_timestring(talloc_tos(), pjob->starttime),
108                    NULL);
109 }
110
111 /****************************************************************************
112 pause a job
113 ****************************************************************************/
114 static int generic_job_pause(int snum, struct printjob *pjob)
115 {
116         fstring jobstr;
117         
118         /* need to pause the spooled entry */
119         slprintf(jobstr, sizeof(jobstr)-1, "%d", pjob->sysjob);
120         return print_run_command(snum, PRINTERNAME(snum), True,
121                                  lp_lppausecommand(snum), NULL,
122                                  "%j", jobstr,
123                                  NULL);
124 }
125
126 /****************************************************************************
127 resume a job
128 ****************************************************************************/
129 static int generic_job_resume(int snum, struct printjob *pjob)
130 {
131         fstring jobstr;
132
133         /* need to pause the spooled entry */
134         slprintf(jobstr, sizeof(jobstr)-1, "%d", pjob->sysjob);
135         return print_run_command(snum, PRINTERNAME(snum), True,
136                                  lp_lpresumecommand(snum), NULL,
137                                  "%j", jobstr,
138                                  NULL);
139 }
140
141 /****************************************************************************
142  Submit a file for printing - called from print_job_end()
143 ****************************************************************************/
144
145 static int generic_job_submit(int snum, struct printjob *pjob)
146 {
147         int ret = -1;
148         char *current_directory = NULL;
149         char *print_directory = NULL;
150         char *wd = NULL;
151         char *p = NULL;
152         char *jobname = NULL;
153         TALLOC_CTX *ctx = talloc_tos();
154         fstring job_page_count, job_size;
155
156         /* we print from the directory path to give the best chance of
157            parsing the lpq output */
158         current_directory = TALLOC_ARRAY(ctx,
159                                         char,
160                                         PATH_MAX+1);
161         if (!current_directory) {
162                 return -1;
163         }
164         wd = sys_getwd(current_directory);
165         if (!wd) {
166                 return -1;
167         }
168
169         print_directory = talloc_strdup(ctx, pjob->filename);
170         if (!print_directory) {
171                 return -1;
172         }
173         p = strrchr_m(print_directory,'/');
174         if (!p) {
175                 return -1;
176         }
177         *p++ = 0;
178
179         if (chdir(print_directory) != 0) {
180                 return -1;
181         }
182
183         jobname = talloc_strdup(ctx, pjob->jobname);
184         if (!jobname) {
185                 ret = -1;
186                 goto out;
187         }
188         jobname = talloc_string_sub(ctx, jobname, "'", "_");
189         if (!jobname) {
190                 ret = -1;
191                 goto out;
192         }
193         slprintf(job_page_count, sizeof(job_page_count)-1, "%d", pjob->page_count);
194         slprintf(job_size, sizeof(job_size)-1, "%lu", (unsigned long)pjob->size);
195
196         /* send it to the system spooler */
197         ret = print_run_command(snum, PRINTERNAME(snum), True,
198                         lp_printcommand(snum), NULL,
199                         "%s", p,
200                         "%J", jobname,
201                         "%f", p,
202                         "%z", job_size,
203                         "%c", job_page_count,
204                         NULL);
205
206  out:
207
208         if (chdir(wd) == -1) {
209                 smb_panic("chdir failed in generic_job_submit");
210         }
211         TALLOC_FREE(current_directory);
212         return ret;
213 }
214
215
216 /****************************************************************************
217 get the current list of queued jobs
218 ****************************************************************************/
219 static int generic_queue_get(const char *printer_name, 
220                              enum printing_types printing_type,
221                              char *lpq_command,
222                              print_queue_struct **q, 
223                              print_status_struct *status)
224 {
225         char **qlines;
226         int fd;
227         int numlines, i, qcount;
228         print_queue_struct *queue = NULL;
229         
230         /* never do substitution when running the 'lpq command' since we can't
231            get it rigt when using the background update daemon.  Make the caller 
232            do it before passing off the command string to us here. */
233
234         print_run_command(-1, printer_name, False, lpq_command, &fd, NULL);
235
236         if (fd == -1) {
237                 DEBUG(5,("generic_queue_get: Can't read print queue status for printer %s\n",
238                         printer_name ));
239                 return 0;
240         }
241         
242         numlines = 0;
243         qlines = fd_lines_load(fd, &numlines,0,NULL);
244         close(fd);
245
246         /* turn the lpq output into a series of job structures */
247         qcount = 0;
248         ZERO_STRUCTP(status);
249         if (numlines && qlines) {
250                 queue = SMB_MALLOC_ARRAY(print_queue_struct, numlines+1);
251                 if (!queue) {
252                         TALLOC_FREE(qlines);
253                         *q = NULL;
254                         return 0;
255                 }
256                 memset(queue, '\0', sizeof(print_queue_struct)*(numlines+1));
257
258                 for (i=0; i<numlines; i++) {
259                         /* parse the line */
260                         if (parse_lpq_entry(printing_type,qlines[i],
261                                             &queue[qcount],status,qcount==0)) {
262                                 qcount++;
263                         }
264                 }               
265         }
266
267         TALLOC_FREE(qlines);
268         *q = queue;
269         return qcount;
270 }
271
272 /****************************************************************************
273  pause a queue
274 ****************************************************************************/
275 static int generic_queue_pause(int snum)
276 {
277         return print_run_command(snum, PRINTERNAME(snum), True, lp_queuepausecommand(snum), NULL, NULL);
278 }
279
280 /****************************************************************************
281  resume a queue
282 ****************************************************************************/
283 static int generic_queue_resume(int snum)
284 {
285         return print_run_command(snum, PRINTERNAME(snum), True, lp_queueresumecommand(snum), NULL, NULL);
286 }
287
288 /****************************************************************************
289  * Generic printing interface definitions...
290  ***************************************************************************/
291
292 struct printif  generic_printif =
293 {
294         DEFAULT_PRINTING,
295         generic_queue_get,
296         generic_queue_pause,
297         generic_queue_resume,
298         generic_job_delete,
299         generic_job_pause,
300         generic_job_resume,
301         generic_job_submit,
302 };
303