1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30 #pragma ident "%Z%%M% %I% %E% SMI"
31
32 /* EMACS_MODES: !fill, lnumb, !overwrite, !nodelete, !picture */
33
34 #include "unistd.h"
35 #include "sys/types.h"
36 #include "sys/stat.h"
37 #include "errno.h"
38 #include "fcntl.h"
39 #include "stdlib.h"
40 #include "string.h"
41
42 #include "lpsched.h"
43
44 static int __list_increment = 16;
45
46 int
list_append(void *** list,void * item)47 list_append(void ***list, void *item)
48 {
49 int count;
50
51 if ((list == NULL) || (item == NULL)) {
52 errno = EINVAL;
53 return (-1);
54 }
55
56 if (item != NULL) {
57 if (*list == NULL)
58 *list = (void **)calloc(__list_increment,
59 sizeof (void *));
60
61 if (*list == NULL)
62 return (-1);
63
64 for (count = 0; (*list)[count] != NULL; count++);
65
66 if ((count + 1) % __list_increment == 0) { /* expand the list */ void **new_list = NULL;
67 int new_size = (((count + 1) / __list_increment) + 1) *
68 __list_increment;
69
70 new_list = (void **)calloc(new_size, sizeof (void *));
71 if (new_list == NULL)
72 return (-1);
73
74 for (count = 0; (*list)[count] != NULL; count++)
75 new_list[count] = (*list)[count];
76 free(*list);
77 *list = new_list;
78 }
79
80 (*list)[count] = item;
81 }
82
83 return (0);
84 }
85
86 void
list_remove(void *** list,void * item)87 list_remove(void ***list, void *item)
88 {
89 int i, count;
90 void **tmp = NULL;
91
92 if ((list == NULL) || (*list == NULL) || (item == NULL))
93 return;
94
95 for (count = 0; (*list)[count] != NULL; count++)
96 ;
97
98 if (count > 0) {
99 int new_size = (((count + 1) / __list_increment) + 1) *
100 __list_increment;
101
102 if ((tmp = (void **)calloc(new_size, sizeof (void *))) == NULL)
103 tmp = *list;
104
105 /* copy up to item */
106 for (i = 0; (((*list)[i] != NULL) && ((*list)[i] != item)); i++)
107 tmp[i] = (*list)[i];
108 /* copy after item */
109 if ((*list)[i] == item)
110 for (++i; ((*list)[i] != NULL); i++)
111 tmp[i-1] = (*list)[i];
112 }
113
114 /* replace the list */
115 if (tmp != *list) {
116 free(*list);
117 *list = tmp;
118 }
119 }
120
121 void
free_exec(EXEC * ep)122 free_exec(EXEC *ep)
123 {
124 if (ep != NULL) {
125 free(ep);
126 list_remove((void ***)&Exec_Table, (void *)ep);
127 }
128 }
129
130 EXEC *
new_exec(int type,void * ex)131 new_exec(int type, void *ex)
132 {
133 EXEC *result = calloc(1, sizeof (*result));
134
135 if (result != NULL) {
136 result->type = type;
137 switch (type) {
138 case EX_ALERT:
139 case EX_INTERF:
140 case EX_FAULT_MESSAGE:
141 result->ex.printer = ex;
142 break;
143 case EX_FALERT:
144 result->ex.form = ex;
145 break;
146 case EX_PALERT:
147 result->ex.pwheel = ex;
148 break;
149 case EX_SLOWF:
150 case EX_NOTIFY:
151 break;
152 }
153 list_append((void ***)&Exec_Table, (void *)result);
154 }
155
156 return (result);
157 }
158
159 void
free_alert(ALERT * ap)160 free_alert(ALERT *ap)
161 {
162 if (ap != NULL) {
163 if (ap->msgfile != NULL)
164 free(ap->msgfile);
165 if (ap->exec != NULL)
166 free_exec(ap->exec);
167 free(ap);
168 }
169 }
170
171 ALERT *
new_alert(char * fmt,int i)172 new_alert(char *fmt, int i)
173 {
174 ALERT *result = calloc(1, sizeof (*result));
175
176 if (result != NULL) {
177 char buf[15];
178
179 snprintf(buf, sizeof (buf), fmt, i);
180 result->msgfile = makepath(Lp_Temp, buf, (char *)0);
181 (void) Unlink(result->msgfile);
182 }
183
184 return (result);
185 }
186
187 void
free_pstatus(PSTATUS * psp)188 free_pstatus(PSTATUS *psp)
189 {
190 if (psp != NULL) {
191 if (psp->alert != NULL)
192 free_alert(psp->alert);
193 if (psp->exec != NULL)
194 free_exec(psp->exec);
195 if (psp->fault_exec != NULL)
196 free_exec(psp->fault_exec);
197 if (psp->printer != NULL)
198 freeprinter(psp->printer);
199 if (psp->pwheel_name != NULL)
200 free(psp->pwheel_name);
201 if (psp->dis_reason != NULL)
202 free(psp->dis_reason);
203 if (psp->rej_reason != NULL)
204 free(psp->rej_reason);
205 if (psp->users_allowed != NULL)
206 unload_list(&psp->users_allowed);
207 if (psp->users_denied != NULL)
208 unload_list(&psp->users_denied);
209 if (psp->forms_allowed != NULL)
210 unload_list(&psp->forms_allowed);
211 if (psp->forms_denied != NULL)
212 unload_list(&psp->forms_denied);
213 if (psp->cpi != NULL)
214 free(psp->cpi);
215 if (psp->lpi != NULL)
216 free(psp->lpi);
217 if (psp->plen != NULL)
218 free(psp->plen);
219 if (psp->pwid != NULL)
220 free(psp->pwid);
221 if (psp->fault_reason != NULL)
222 free(psp->fault_reason);
223 if (psp->paper_allowed != NULL)
224 unload_list(&psp->paper_allowed);
225 free(psp);
226 }
227 }
228
229 void
pstatus_add_printer(PSTATUS * ps,PRINTER * p)230 pstatus_add_printer(PSTATUS *ps, PRINTER *p)
231 {
232 if ((ps != NULL) && (p != NULL)) {
233 char **paperDenied = NULL;
234
235 ps->printer = p;
236 load_userprinter_access(p->name, &(ps->users_allowed),
237 &(ps->users_denied));
238 load_formprinter_access(p->name, &(ps->forms_allowed),
239 &(ps->forms_denied));
240 load_paperprinter_access(p->name, &ps->paper_allowed,
241 &paperDenied);
242 freelist(paperDenied);
243 load_sdn(&(ps->cpi), p->cpi);
244 load_sdn(&(ps->lpi), p->lpi);
245 load_sdn(&(ps->plen), p->plen);
246 load_sdn(&(ps->pwid), p->pwid);
247 }
248 }
249
250 PSTATUS *
new_pstatus(PRINTER * p)251 new_pstatus(PRINTER *p)
252 {
253 PSTATUS *result = calloc(1, sizeof (*result));
254
255 if (result != NULL) {
256 static int i = 0;
257 char **paperDenied = NULL;
258
259 result->alert = new_alert("A-%d", i++);
260 result->alert->exec = new_exec(EX_ALERT, result);
261 result->exec = new_exec(EX_INTERF, result);
262 result->fault_exec = new_exec(EX_FAULT_MESSAGE, result);
263
264 if (p != NULL)
265 pstatus_add_printer(result, p);
266
267 list_append((void ***)&PStatus, (void *)result);
268 }
269
270 return (result);
271 }
272
273 void
free_cstatus(CSTATUS * csp)274 free_cstatus(CSTATUS *csp)
275 {
276 if (csp != NULL) {
277 if (csp->rej_reason != NULL)
278 free(csp->rej_reason);
279 if (csp->class != NULL)
280 freeclass(csp->class);
281 free(csp);
282 }
283 }
284
285 CSTATUS *
new_cstatus(CLASS * c)286 new_cstatus(CLASS *c)
287 {
288 CSTATUS *result = calloc(1, sizeof (*result));
289
290 if (result != NULL) {
291 if (c != NULL)
292 result->class = c;
293 else
294 result->class = calloc(1, sizeof (CLASS));
295
296 list_append((void ***)&CStatus, result);
297 }
298
299 return (result);
300 }
301
302 void
free_fstatus(FSTATUS * fsp)303 free_fstatus(FSTATUS *fsp)
304 {
305 if (fsp != NULL) {
306 if (fsp->form != NULL)
307 free_form(fsp->form);
308 if (fsp->alert != NULL)
309 free_alert(fsp->alert);
310 if (fsp->users_allowed != NULL)
311 unload_list(&fsp->users_allowed);
312 if (fsp->users_denied != NULL)
313 unload_list(&fsp->users_denied);
314 if (fsp->cpi != NULL)
315 free(fsp->cpi);
316 if (fsp->lpi != NULL)
317 free(fsp->lpi);
318 if (fsp->plen != NULL)
319 free(fsp->plen);
320 if (fsp->pwid != NULL)
321 free(fsp->pwid);
322 free(fsp);
323 }
324 }
325
326 FSTATUS *
new_fstatus(_FORM * f)327 new_fstatus(_FORM *f)
328 {
329 FSTATUS *result = calloc(1, sizeof (*result));
330
331 if (result != NULL) {
332 static int i = 0;
333
334 if (f != NULL)
335 result->form = f;
336 else
337 result->form = calloc(1, sizeof (_FORM));
338
339 result->alert = new_alert("F-%d", i++);
340 result->alert->exec = new_exec(EX_FALERT, result);
341 result->trigger = result->form->alert.Q;
342
343 if (f != NULL) {
344 load_userform_access(f->name, &(result->users_allowed),
345 &(result->users_denied));
346 load_sdn (&(result->cpi), f->cpi);
347 load_sdn (&(result->lpi), f->lpi);
348 load_sdn (&(result->plen), f->plen);
349 load_sdn (&(result->pwid), f->pwid);
350 }
351
352 list_append((void ***)&FStatus, (void *)result);
353 }
354
355 return (result);
356 }
357
358 void
free_pwstatus(PWSTATUS * pwp)359 free_pwstatus(PWSTATUS *pwp)
360 {
361 if (pwp != NULL) {
362 if (pwp->pwheel)
363 freepwheel(pwp->pwheel);
364 if (pwp->alert != NULL)
365 free_alert(pwp->alert);
366 free(pwp);
367 }
368 }
369
370 PWSTATUS *
new_pwstatus(PWHEEL * p)371 new_pwstatus(PWHEEL *p)
372 {
373 PWSTATUS *result = calloc(1, sizeof (*result));
374
375 if (result != NULL) {
376 static int i = 0;
377
378 if (p != NULL)
379 result->pwheel = p;
380 else
381 result->pwheel = calloc(1, sizeof (*result));
382
383 result->alert = new_alert("P-%d", i++);
384 result->alert->exec = new_exec(EX_PALERT, result);
385 result->trigger = result->pwheel->alert.Q;
386
387 list_append((void ***)&PWStatus, (void *)result);
388 }
389
390 return (result);
391 }
392
393 void
free_rstatus(RSTATUS * rsp)394 free_rstatus(RSTATUS *rsp)
395 {
396 if (rsp != NULL) {
397 remover(rsp);
398
399 if (rsp->request != NULL)
400 freerequest(rsp->request);
401 if (rsp->secure != NULL)
402 freesecure(rsp->secure);
403 if (rsp->req_file)
404 Free (rsp->req_file);
405 if (rsp->slow)
406 Free (rsp->slow);
407 if (rsp->fast)
408 Free (rsp->fast);
409 if (rsp->pwheel_name)
410 Free (rsp->pwheel_name);
411 if (rsp->printer_type)
412 Free (rsp->printer_type);
413 if (rsp->output_type)
414 Free (rsp->output_type);
415 if (rsp->cpi)
416 Free (rsp->cpi);
417 if (rsp->lpi)
418 Free (rsp->lpi);
419 if (rsp->plen)
420 Free (rsp->plen);
421 if (rsp->pwid)
422 Free (rsp->pwid);
423 free(rsp);
424 }
425 }
426
427 RSTATUS *
new_rstatus(REQUEST * r,SECURE * s)428 new_rstatus(REQUEST *r, SECURE *s)
429 {
430 RSTATUS *result = calloc(1, sizeof (*result));
431
432 if (result != NULL) {
433 if ((result->request = r) == NULL)
434 result->request = calloc(1, sizeof (REQUEST));
435 if ((result->secure = s) == NULL)
436 result->secure = calloc(1, sizeof (SECURE));
437 }
438
439 return (result);
440 }
441
442 /**
443 ** search_pstatus() - SEARCH PRINTER TABLE
444 ** search_fstatus() - SEARCH FORMS TABLE
445 ** search_cstatus() - SEARCH CLASS TABLE
446 ** search_pwstatus() - SEARCH PRINT WHEEL TABLE
447 **/
448
449 PSTATUS *
search_pstatus(register char * name)450 search_pstatus(register char *name)
451 {
452 PSTATUS *ps = NULL;
453
454 if (name != NULL) {
455 if (PStatus != NULL) {
456 int i;
457
458 for (i = 0; ((PStatus[i] != NULL) && (ps == NULL)); i++)
459 if (SAME(PStatus[i]->printer->name, name))
460 ps = PStatus[i];
461 }
462 } else
463 ps = new_pstatus(NULL);
464
465 return (ps);
466 }
467
468
469 FSTATUS *
search_fstatus(register char * name)470 search_fstatus(register char *name)
471 {
472 FSTATUS *ps = NULL;
473
474 if (name != NULL) {
475 if (FStatus != NULL) {
476 int i;
477
478 for (i = 0; ((FStatus[i] != NULL) && (ps == NULL)); i++)
479 if (SAME(FStatus[i]->form->name, name))
480 ps = FStatus[i];
481 }
482 } else
483 ps = new_fstatus(NULL);
484
485 return (ps);
486 }
487
488 FSTATUS *
search_fptable(register char * paper)489 search_fptable(register char *paper)
490 {
491 FSTATUS *ps = NULL;
492 int i;
493
494 if (FStatus != NULL) {
495 for (i = 0; ((FStatus[i] != NULL) && (ps == NULL)); i++)
496 if (SAME(FStatus[i]->form->paper, paper)) {
497 if (ps->form->isDefault)
498 ps = FStatus[i];
499 }
500 }
501
502 return (ps);
503 }
504
505 CSTATUS *
search_cstatus(register char * name)506 search_cstatus(register char *name)
507 {
508 CSTATUS *ps = NULL;
509
510 if (name != NULL) {
511 if (CStatus != NULL) {
512 int i;
513
514 for (i = 0; ((CStatus[i] != NULL) && (ps == NULL)); i++)
515 if (SAME(CStatus[i]->class->name, name))
516 ps = CStatus[i];
517 }
518 } else
519 ps = new_cstatus(NULL);
520
521 return (ps);
522 }
523
524 PWSTATUS *
search_pwstatus(register char * name)525 search_pwstatus(register char *name)
526 {
527 PWSTATUS *ps = NULL;
528
529 if (name != NULL) {
530 if (PWStatus != NULL) {
531 int i;
532
533 for (i = 0; ((PWStatus[i] != NULL) && (ps == NULL)); i++)
534 if (SAME(PWStatus[i]->pwheel->name, name))
535 ps = PWStatus[i];
536 }
537 } else
538 ps = new_pwstatus(NULL);
539
540 return (ps);
541 }
542
543
544 /**
545 ** load_str() - LOAD STRING WHERE ALLOC'D STRING MAY BE
546 ** unload_str() - REMOVE POSSIBLE ALLOC'D STRING
547 **/
548
549 void
load_str(char ** pdst,char * src)550 load_str(char **pdst, char *src)
551 {
552 if (*pdst)
553 Free (*pdst);
554 *pdst = Strdup(src);
555 return;
556 }
557
558 void
unload_str(char ** pdst)559 unload_str(char **pdst)
560 {
561 if (*pdst)
562 Free (*pdst);
563 *pdst = 0;
564 return;
565 }
566
567 /**
568 ** unload_list() - REMOVE POSSIBLE ALLOC'D LIST
569 **/
570
571 void
unload_list(char *** plist)572 unload_list(char ***plist)
573 {
574 if (*plist)
575 freelist (*plist);
576 *plist = 0;
577 return;
578 }
579
580 /**
581 ** load_sdn() - LOAD STRING WITH ASCII VERSION OF SCALED DECIMAL NUMBER
582 **/
583
584 void
load_sdn(char ** p,SCALED sdn)585 load_sdn(char **p, SCALED sdn)
586 {
587 if (!p)
588 return;
589
590 if (*p)
591 Free (*p);
592 *p = 0;
593
594 if (sdn.val <= 0 || 999999 < sdn.val)
595 return;
596
597 *p = Malloc(sizeof("999999.999x"));
598 sprintf (
599 *p,
600 "%.3f%s",
601 sdn.val,
602 (sdn.sc == 'c'? "c" : (sdn.sc == 'i'? "i" : ""))
603 );
604
605 return;
606 }
607
608 /**
609 ** Getform() - EASIER INTERFACE TO "getform()"
610 **/
611
612 _FORM *
Getform(char * form)613 Getform(char *form)
614 {
615 _FORM *_form;
616
617 FORM formbuf;
618
619 FALERT alertbuf;
620
621 int ret;
622
623
624 while (
625 (ret = getform(form, &formbuf, &alertbuf, (FILE **)0)) == -1
626 && errno == EINTR
627 )
628 ;
629 if (ret == -1)
630 return (0);
631
632 _form = calloc(1, sizeof (*_form));
633 _form->plen = formbuf.plen;
634 _form->pwid = formbuf.pwid;
635 _form->lpi = formbuf.lpi;
636 _form->cpi = formbuf.cpi;
637 _form->np = formbuf.np;
638 _form->chset = formbuf.chset;
639 _form->mandatory = formbuf.mandatory;
640 _form->rcolor = formbuf.rcolor;
641 _form->comment = formbuf.comment;
642 _form->conttype = formbuf.conttype;
643 _form->name = formbuf.name;
644 _form->paper = formbuf.paper;
645 _form->isDefault = formbuf.isDefault;
646
647 if ((_form->alert.shcmd = alertbuf.shcmd) != NULL) {
648 _form->alert.Q = alertbuf.Q;
649 _form->alert.W = alertbuf.W;
650 } else {
651 _form->alert.Q = 0;
652 _form->alert.W = 0;
653 }
654
655 return (_form);
656 }
657
658 /**
659 ** Getprinter()
660 ** Getrequest()
661 ** Getuser()
662 ** Getclass()
663 ** Getpwheel()
664 ** Getsecure()
665 ** Loadfilters()
666 **/
667
668 PRINTER *
Getprinter(char * name)669 Getprinter(char *name)
670 {
671 register PRINTER *ret;
672
673 while (!(ret = getprinter(name)) && errno == EINTR)
674 ;
675 return (ret);
676 }
677
678 REQUEST *
Getrequest(char * file)679 Getrequest(char *file)
680 {
681 register REQUEST *ret;
682
683 while (!(ret = getrequest(file)) && errno == EINTR)
684 ;
685 return (ret);
686 }
687
688 USER *
Getuser(char * name)689 Getuser(char *name)
690 {
691 register USER *ret;
692
693 while (!(ret = getuser(name)) && errno == EINTR)
694 ;
695 return (ret);
696 }
697
698 CLASS *
Getclass(char * name)699 Getclass(char *name)
700 {
701 register CLASS *ret;
702
703 while (!(ret = getclass(name)) && errno == EINTR)
704 ;
705 return (ret);
706 }
707
708 PWHEEL *
Getpwheel(char * name)709 Getpwheel(char *name)
710 {
711 register PWHEEL *ret;
712
713 while (!(ret = getpwheel(name)) && errno == EINTR)
714 ;
715 return (ret);
716 }
717
718 SECURE *
Getsecure(char * file)719 Getsecure(char *file)
720 {
721 register SECURE *ret;
722
723 while (!(ret = getsecure(file)) && errno == EINTR)
724 ;
725 return ((SECURE *) ret);
726 }
727
728
729 int
Loadfilters(char * file)730 Loadfilters(char *file)
731 {
732 register int ret;
733
734 while ((ret = loadfilters(file)) == -1 && errno == EINTR)
735 ;
736 return (ret);
737 }
738
739 /**
740 ** free_form() - FREE MEMORY ALLOCATED FOR _FORM STRUCTURE
741 **/
742
743 void
free_form(register _FORM * pf)744 free_form(register _FORM *pf)
745 {
746 if (!pf)
747 return;
748 if (pf->chset)
749 Free (pf->chset);
750 if (pf->rcolor)
751 Free (pf->rcolor);
752 if (pf->comment)
753 Free (pf->comment);
754 if (pf->conttype)
755 Free (pf->conttype);
756 if (pf->name)
757 Free (pf->name);
758 if (pf->paper)
759 Free (pf->paper);
760 pf->name = 0;
761 if (pf->alert.shcmd)
762 Free (pf->alert.shcmd);
763 return;
764 }
765
766 /**
767 ** getreqno() - GET NUMBER PART OF REQUEST ID
768 **/
769
770 char *
getreqno(char * req_id)771 getreqno(char *req_id)
772 {
773 register char *cp;
774
775
776 if (!(cp = strrchr(req_id, '-')))
777 cp = req_id;
778 else
779 cp++;
780 return (cp);
781 }
782
783 /* Putsecure(): Insurance for writing out the secure request file.
784 * input: char ptr to name of the request file,
785 * ptr to the SECURE structure to be written.
786 * ouput: 0 if successful, -1 otherwise.
787 *
788 * Description:
789 * The normal call to putsecure() is woefully lacking.
790 * The bottom line here is that there
791 * is no way to make sure that the file has been written out
792 * as expected. This can cause rude behaviour later on.
793 *
794 * This routine calls putsecure(), and then does a getsecure().
795 * The results are compared to the original structure. If the
796 * info obtained by getsecure() doesn't match, we retry a few
797 * times before giving up (presumably something is very seriously
798 * wrong at that point).
799 */
800
801
802 int
Putsecure(char * file,SECURE * secbufp)803 Putsecure(char *file, SECURE *secbufp)
804 {
805 SECURE *pls;
806 int retries = 5; /* # of attempts */
807 int status; /* 0 = success, nonzero otherwise */
808
809
810 while (retries--) {
811 status = 1; /* assume the worst, hope for the best */
812 if (putsecure(file, secbufp) == -1) {
813 rmsecure(file);
814 continue;
815 }
816
817 if ((pls = getsecure(file)) == (SECURE *) NULL) {
818 rmsecure(file);
819 status = 2;
820 continue;
821 }
822
823 /* now compare each field */
824
825 /*
826 * A comparison is only valid if secbufp and pls point to
827 * different locations. In reality getsecure() will have
828 * already been called, allocating the same STATIC memory
829 * location to both structures making the following compare
830 * meaningless.
831 * Therefore test for this condition to prevent us from
832 * calling freesecure which will destroy uid and
833 * req_id fields in the strucure
834 */
835
836 status = 0;
837 if (secbufp != pls) {
838 if (strcmp(pls->req_id, secbufp->req_id) != 0) {
839 rmsecure(file);
840 status = 3;
841 continue;
842 }
843
844 if (pls->uid != secbufp->uid) {
845 rmsecure(file);
846 status = 4;
847 continue;
848 }
849
850 if (strcmp(pls->user, secbufp->user) != 0) {
851 rmsecure(file);
852 status = 5;
853 continue;
854 }
855
856 if (pls->gid != secbufp->gid) {
857 rmsecure(file);
858 status = 6;
859 continue;
860 }
861
862 if (pls->size != secbufp->size) {
863 rmsecure(file);
864 status = 7;
865 continue;
866 }
867
868 if (pls->date != secbufp->date) {
869 rmsecure(file);
870 status = 8;
871 continue;
872 }
873
874 freesecure(pls);
875 }
876 break;
877 }
878
879 if (status != 0) {
880 note("Putsecure failed, status=%d\n", status);
881 return -1;
882 }
883
884 return 0;
885 }
886
GetRequestFiles(REQUEST * req,char * buffer,int length)887 void GetRequestFiles(REQUEST *req, char *buffer, int length)
888 {
889 char buf[BUFSIZ];
890
891 memset(buf, 0, sizeof(buf));
892
893 if (req->title) {
894 char *r = req->title;
895 char *ptr = buf;
896
897 while ( *r && strncmp(r,"\\n",2)) {
898 *ptr++ = *r++;
899 }
900 } else if (req->file_list)
901 strlcpy(buf, *req->file_list, sizeof (buf));
902
903 if (*buf == NULL || !strncmp(buf, SPOOLDIR, sizeof(SPOOLDIR)-1))
904 strcpy(buf, "<File name not available>");
905
906 if (strlen(buf) > (size_t) 24) {
907 char *r;
908
909 if (r = strrchr(buf, '/'))
910 r++;
911 else
912 r = buf;
913
914 snprintf(buffer, length, "%-.24s", r);
915 } else
916 strlcpy(buffer, buf, length);
917 return;
918 }
919
920
921 /**
922 ** _Malloc()
923 ** _Realloc()
924 ** _Calloc()
925 ** _Strdup()
926 ** _Free()
927 **/
928
929 void (*lp_alloc_fail_handler)( void ) = 0;
930
931 typedef void *alloc_type;
932
933 alloc_type
_Malloc(size_t size,const char * file,int line)934 _Malloc(size_t size, const char *file, int line)
935 {
936 alloc_type ret;
937
938 ret = malloc(size);
939 if (!ret) {
940 if (lp_alloc_fail_handler)
941 (*lp_alloc_fail_handler)();
942 errno = ENOMEM;
943 }
944 return (ret);
945 }
946
947 alloc_type
_Realloc(void * ptr,size_t size,const char * file,int line)948 _Realloc(void *ptr, size_t size, const char *file, int line)
949 {
950 alloc_type ret = realloc(ptr, size);
951
952 if (!ret) {
953 if (lp_alloc_fail_handler)
954 (*lp_alloc_fail_handler)();
955 errno = ENOMEM;
956 }
957 return (ret);
958 }
959
960 alloc_type
_Calloc(size_t nelem,size_t elsize,const char * file,int line)961 _Calloc(size_t nelem, size_t elsize, const char *file, int line)
962 {
963 alloc_type ret = calloc(nelem, elsize);
964
965 if (!ret) {
966 if (lp_alloc_fail_handler)
967 (*lp_alloc_fail_handler)();
968 errno = ENOMEM;
969 }
970 return (ret);
971 }
972
973 char *
_Strdup(const char * s,const char * file,int line)974 _Strdup(const char *s, const char *file, int line)
975 {
976 char * ret;
977
978 if (!s)
979 return( (char *) 0);
980
981 ret = strdup(s);
982
983 if (!ret) {
984 if (lp_alloc_fail_handler)
985 (*lp_alloc_fail_handler)();
986 errno = ENOMEM;
987 }
988 return (ret);
989 }
990
991 void
_Free(void * ptr,const char * file,int line)992 _Free(void *ptr, const char *file, int line)
993 {
994 free (ptr);
995 return;
996 }
997