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, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 1990 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 /* EMACS_MODES: !fill, lnumb, !overwrite, !nodelete, !picture */ 31 32 #include "string.h" 33 #include "errno.h" 34 #include "stdlib.h" 35 #include "regexpr.h" 36 37 #include "lp.h" 38 #include "filters.h" 39 40 static char *keyword_list[] = { 41 PARM_INPUT, 42 PARM_OUTPUT, 43 PARM_TERM, 44 PARM_PRINTER, 45 PARM_CPI, 46 PARM_LPI, 47 PARM_LENGTH, 48 PARM_WIDTH, 49 PARM_PAGES, 50 PARM_CHARSET, 51 PARM_FORM, 52 PARM_COPIES, 53 PARM_MODES, 54 0 55 }; 56 57 #if defined(__STDC__) 58 static char * q_strchr ( char * , char ); 59 static char * q_strdup ( char * ); 60 #else 61 static char *q_strchr(), 62 *q_strdup(); 63 #endif 64 65 /** 66 ** s_to_filtertype() - CONVERT (char *) TO (FILTERTYPE) 67 **/ 68 69 FILTERTYPE 70 #if defined(__STDC__) 71 s_to_filtertype ( 72 char * str 73 ) 74 #else 75 s_to_filtertype (str) 76 char *str; 77 #endif 78 { 79 /* 80 * The default type, if none is given, is ``slow''. 81 */ 82 if (STREQU(str, FL_FAST)) 83 return (fl_fast); 84 else 85 return (fl_slow); 86 } 87 88 /** 89 ** s_to_type() - CONVERT (char *) TO (TYPE) 90 **/ 91 92 TYPE 93 #if defined(__STDC__) 94 s_to_type ( 95 char * str 96 ) 97 #else 98 s_to_type (str) 99 register char *str; 100 #endif 101 { 102 TYPE ret; 103 104 if ((ret.name = Strdup(str))) 105 ret.info = isterminfo(str); 106 return (ret); 107 } 108 109 /** 110 ** s_to_template() - CONVERT (char *) TO (TEMPLATE) 111 **/ 112 113 TEMPLATE 114 #if defined(__STDC__) 115 s_to_template ( 116 char * str 117 ) 118 #else 119 s_to_template (str) 120 register char *str; 121 #endif 122 { 123 TEMPLATE ret; 124 125 register char *p, 126 c; 127 128 129 if (!*(str += strspn(str, " "))) { 130 lp_errno = LP_ETEMPLATE; 131 ret.keyword = 0; 132 goto Done; 133 } 134 135 if (!(p = strchr(str, ' '))) { 136 lp_errno = LP_EPATTERN; 137 ret.keyword = 0; 138 goto Done; 139 } 140 141 c = *p; 142 *p = 0; 143 ret.keyword = Strdup(str); 144 *p = c; 145 146 if (!ret.keyword) { 147 lp_errno = LP_ENOMEM; 148 goto Done; 149 } 150 if (!searchlist(ret.keyword, keyword_list)) { 151 lp_errno = LP_EKEYWORD; 152 ret.keyword = 0; 153 goto Done; 154 } 155 156 str = p + strspn(p, " "); 157 if (!(p = q_strchr(str, '='))) { 158 lp_errno = LP_ERESULT; 159 ret.keyword = 0; 160 goto Done; 161 } 162 while (p[-1] == ' ' && p > str) 163 p--; 164 165 c = *p; 166 *p = 0; 167 ret.pattern = q_strdup(str); 168 *p = c; 169 170 if (!ret.pattern) { 171 lp_errno = LP_ENOMEM; 172 ret.keyword = 0; 173 goto Done; 174 } 175 176 if (!*ret.pattern) { 177 lp_errno = LP_EPATTERN; 178 ret.keyword = 0; 179 goto Done; 180 } 181 182 if (!(ret.re = compile(ret.pattern, (char *)0, (char *)0))) { 183 lp_errno = LP_EREGEX; 184 ret.keyword = 0; 185 goto Done; 186 } 187 ret.nbra = nbra; 188 189 if (!*(str = p + strspn(p, " ="))) { 190 lp_errno = LP_ERESULT; 191 ret.keyword = 0; 192 goto Done; 193 } 194 ret.result = q_strdup(str); 195 if (!ret.result) { 196 lp_errno = LP_ENOMEM; 197 ret.keyword = 0; 198 } 199 200 Done: return (ret); 201 } 202 203 /** 204 ** sl_to_typel() - CONVERT (char **) LIST TO (TYPE *) LIST 205 **/ 206 207 TYPE * 208 #if defined(__STDC__) 209 sl_to_typel ( 210 char ** src 211 ) 212 #else 213 sl_to_typel (src) 214 char **src; 215 #endif 216 { 217 register TYPE *dst; 218 219 register int nitems, 220 n; 221 222 if (!src || !*src) 223 return (0); 224 225 for (nitems = 0; src[nitems]; nitems++) 226 ; 227 228 if (!(dst = (TYPE *)Malloc((nitems + 1) * sizeof(TYPE)))) { 229 errno = ENOMEM; 230 return (0); 231 } 232 233 for (n = 0; n < nitems; n++) 234 dst[n] = s_to_type(src[n]); 235 dst[nitems].name = 0; 236 237 return (dst); 238 } 239 240 /** 241 ** sl_to_templatel() - DUPLICATE A (char **) LIST AS (TEMPLATE *) LIST 242 **/ 243 244 TEMPLATE * 245 #if defined(__STDC__) 246 sl_to_templatel ( 247 char ** src 248 ) 249 #else 250 sl_to_templatel (src) 251 register char **src; 252 #endif 253 { 254 register TEMPLATE *dst; 255 256 register int nitems, 257 n; 258 259 if (!src || !*src) 260 return (0); 261 262 for (nitems = 0; src[nitems]; nitems++) 263 ; 264 265 if (!(dst = (TEMPLATE *)Malloc((nitems + 1) * sizeof(TEMPLATE)))){ 266 errno = ENOMEM; 267 return (0); 268 } 269 270 for (n = 0; n < nitems; n++) { 271 dst[n] = s_to_template(src[n]); 272 if (dst[n].keyword == 0) { 273 freetempl (dst); 274 return (0); 275 } 276 } 277 dst[nitems].keyword = 0; 278 279 return (dst); 280 } 281 282 /** 283 ** type_to_s() - CONVERT (TYPE) TO (char *) 284 **/ 285 286 char * 287 #if defined(__STDC__) 288 type_to_s ( 289 TYPE t 290 ) 291 #else 292 type_to_s (t) 293 TYPE t; 294 #endif 295 { 296 return (Strdup(t.name)); 297 } 298 299 /** 300 ** template_to_s() - CONVERT (TEMPLATE) TO (char *) 301 **/ 302 303 char * 304 #if defined(__STDC__) 305 template_to_s ( 306 TEMPLATE t 307 ) 308 #else 309 template_to_s (t) 310 TEMPLATE t; 311 #endif 312 { 313 register char *ret, 314 *p, 315 *r; 316 317 register size_t len; 318 319 320 len = strlen(t.keyword) + 1; 321 for (p = t.pattern; *p; p++) { 322 if (*p == '=') 323 len++; 324 len++; 325 } 326 len += 3 + strlen(t.result); 327 328 ret = Malloc(len + 1); 329 if (!ret) { 330 errno = ENOMEM; 331 return (0); 332 } 333 334 r = ret; 335 for (p = t.keyword; *p; ) 336 *r++ = *p++; 337 *r++ = ' '; 338 for (p = t.pattern; *p; ) { 339 if (*p == '=') 340 *r++ = '\\'; 341 *r++ = *p++; 342 } 343 *r++ = ' '; 344 *r++ = '='; 345 *r++ = ' '; 346 for (p = t.result; *p; ) 347 *r++ = *p++; 348 *r = 0; 349 350 return (ret); 351 } 352 353 /** 354 ** typel_to_sl() - DUPLICATE (TYPE *) LIST AS (char **) LIST 355 **/ 356 357 char ** 358 #if defined(__STDC__) 359 typel_to_sl ( 360 TYPE * src 361 ) 362 #else 363 typel_to_sl (src) 364 TYPE *src; 365 #endif 366 { 367 register char **dst; 368 369 register size_t nitems; 370 371 register int n; 372 373 374 if (!src || !src->name) 375 return (0); 376 377 for (nitems = 0; src[nitems].name; nitems++) 378 ; 379 380 if (!(dst = (char **)Malloc((nitems + 1) * sizeof(char *)))) { 381 errno = ENOMEM; 382 return (0); 383 } 384 385 for (n = 0; n < nitems; n++) 386 dst[n] = type_to_s(src[n]); 387 dst[nitems] = 0; 388 389 return (dst); 390 } 391 392 /** 393 ** templatel_to_sl() - DUPLICATE A (TEMPLATE *) LIST AS (char **) LIST 394 **/ 395 396 char ** 397 #if defined(__STDC__) 398 templatel_to_sl ( 399 TEMPLATE * src 400 ) 401 #else 402 templatel_to_sl (src) 403 register TEMPLATE *src; 404 #endif 405 { 406 register char **dst; 407 408 register size_t nitems; 409 410 register int n; 411 412 413 if (!src || !src->keyword) 414 return (0); 415 416 for (nitems = 0; src[nitems].keyword; nitems++) 417 ; 418 419 if (!(dst = (char **)Malloc((nitems + 1) * sizeof(char *)))) { 420 errno = ENOMEM; 421 return (0); 422 } 423 424 for (n = 0; n < nitems; n++) 425 dst[n] = template_to_s(src[n]); 426 dst[nitems] = 0; 427 428 return (dst); 429 } 430 431 /** 432 ** q_strpbrk() - strpbrk() WITH BACKSLASH QUOTING 433 ** q_strdup() - strdup() WITH BACKSLASHES OMITTED 434 **/ 435 436 static char * 437 #if defined(__STDC__) 438 q_strchr ( 439 char * sp, 440 char c 441 ) 442 #else 443 q_strchr (sp, c) 444 register char *sp, 445 c; 446 #endif 447 { 448 do { 449 if (*sp == '\\' && sp[1]) 450 sp += 2; 451 if (*sp == c) 452 return (sp); 453 } while (*sp++); 454 return (0); 455 } 456 457 static char * 458 #if defined(__STDC__) 459 q_strdup ( 460 char * str 461 ) 462 #else 463 q_strdup (str) 464 char *str; 465 #endif 466 { 467 char *ret; 468 469 register char *p, 470 *q; 471 472 register int len = 0; 473 474 475 for (p = str; *p; p++) { 476 if (*p == '\\' && p[1] == '=') 477 p++; 478 len++; 479 } 480 481 if (!(ret = q = Malloc(len + 1))) 482 return (0); 483 484 for (p = str; *p; p++) { 485 if (*p == '\\' && p[1] == '=') 486 p++; 487 *q++ = *p; 488 } 489 *q = 0; 490 491 return (ret); 492 } 493