xref: /titanic_41/usr/src/cmd/print/scripts/ppdmgr (revision fcf3ce441efd61da9bb2884968af01cb7c1452cc)
1#!/bin/ksh
2#
3# CDDL HEADER START
4#
5# The contents of this file are subject to the terms of the
6# Common Development and Distribution License (the "License").
7# You may not use this file except in compliance 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# Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23# Use is subject to license terms.
24#
25
26#
27# Description: Script to generate the Solaris printmgr 'ppdcache' file from the
28#              ppd files installed in the given ppd database directory
29#
30# ppdmgr -a <ppd_filename_path> [ -L <label> ] [-w]
31# ppdmgr -g <ppd_filename_path> [ -L <label> ] [ -R <ppd_repository> ]
32# ppdmgr -r [ -L <label> ] [ -R <ppd_repository> ]
33# ppdmgr -u [ -L <label> ] [ -R <ppd_repository> ]
34#
35# Options:
36#		-a <ppd_filename_path>	- Add a new PPD file to the specified
37#					label in the "user" repository, and
38#					updates to the "user" repository
39#					in the ppdcache.
40#		-g <ppd_filename_path>	- Generate a cache file entry
41#					for the specified PPD file
42#					on standard out.
43#		-L <label>		- Label name.  <label>
44#					can be any characters from the
45#					portable character set, however
46#					may not contain a semi-colon (':').
47#					The following are the defaults
48#					for <label> for each option:
49#					OPTION	DEFAULT LABEL
50#					------	-------------
51#					-a	<label> from <ppd_filename_path>
52#						if <ppd_filename_path>
53#						is from a known repository,
54#						otherwise defaults to "user".
55#					-g	<label> from <ppd_filename_path>
56#						if <ppd_filename_path>
57#						is from a known repository,
58#						otherwise defaults to "user".
59#					-r	all
60#					-u	all
61#					The following are reserved labels:
62#					caches		- may never be specified
63#					ppdcache	- may never be specified
64#					manufaliases	- may never be specified
65#					all		- applies specified
66#							action to all labels
67#							in a repository.
68#							Can only be specified
69#							with -r or -u.
70#					SUNW*		- anything starting with
71#							SUNW is reserved for
72#							use by Sun, but not
73#							prohibited.
74#		-r			- Rebuild the cache information for the
75#					specified label in the specified
76#					repository.  Similar to -u, however,
77#					the cache file is removed to force an
78#					update to the ppdcache.
79#		-R <ppd_repository>	- PPD repository name.
80#					Defaults to "user".
81#					The following are the possible
82#					values for <ppd_repository> and
83#					location in the system:
84#					REP	LOCATION
85#					---	--------
86#					user	/var/lp/ppd
87#					admin	/usr/local/share/ppd
88#					vendor	/opt/share/ppd
89#					system	/usr/share/ppd
90#					all	all repositories
91#
92#					Note: When specified with the -a option
93#					only "user" and "admin" are valid.
94#					"vendor", "system", and "all" will be
95#					considered reserved.
96#		-u			- Update the PPD cache information
97#					for the specified label in the specified
98#					repository if needed.  If the cache
99#					update was required, then the updated
100#					cache information is reflected in
101#					the ppdcache.
102#		-w			- Display full path of where the
103#					ppd file is located on the system.
104#					Only valid with -a, otherwise the
105#					option is ignored.
106#
107# If -a, -g, -r, or -u are specified on the command line, only the last action
108# specified will be performed.
109#
110# Cache file entry format:
111#	<ModifiedManufacturerName>:<Model>:<NickName>:<1284DeviceIDManufacturer>:<1284DeviceIDModel>:<FullPPDFilePath>
112#	HP:HP DeskJet 450:Foomatic/hpijs (recommended):dj450:hp:/usr/share/ppd/HP/HP-DeskJet_450-hpijs.ppd.gz
113#
114
115PATH=/bin:/usr/bin:/usr/sbin export PATH
116set -o noclobber
117
118TEXTDOMAIN="SUNW_OST_OSCMD"
119export TEXTDOMAIN
120
121#
122# Generates debug output for calling routine.
123# If calling routine's name is passed in, then
124# will also generate the name of the calling routine.
125#
126# $1	- Name of calling routine
127debugger()
128{
129	[[ ${debug} -eq 1 ]] || return 1
130	if [[ -n "${1}" ]] ; then
131		echo "In ${1}..." 1>&2
132	fi
133	return 0
134}
135
136#
137# Set the ownership and permissions on a file.
138#
139# $1	- Mode
140# $2	- Owner:Group
141# $3	- Full path to file
142#
143set_perms()
144{
145	/bin/chmod -f ${1} "${3}" >/dev/null 2>&1
146	/bin/chown -f ${2} "${3}" >/dev/null 2>&1
147}
148
149#
150# Create administrator repository directories, /usr/local/share/ppd,
151# if needed. This is a special case a Solaris doesn't deliver
152# /usr/local/share and it has different permissions than the
153# user repository.
154#
155# $1	- destination repository name
156#
157create_adminrep_dirs()
158{
159	if debugger "check_adminrep_dirs" ; then
160		set -x
161	fi
162
163	# Only create administrator repository directories, if needed.
164	[[ "${1}" = "${ADMIN}" ]] || return 0
165
166	# Check /usr/local/share/ppd
167	[[ ! -d "${ADMINREP}" ]] || return 0
168
169	# Check /usr/local/share
170	admpar=$(/bin/dirname "${ADMINREP}")
171	if [[ ! -d "${admpar}" ]] ; then
172
173		# Check /usr/local
174		admppar=$(/bin/dirname "${admpar}")
175		if [[ ! -d "${admppar}" ]] ; then
176			make_dir ${DIRMODE} ${ADMINOWNER} "${admppar}" || \
177			    return 1
178		fi
179		make_dir ${DIRMODE} ${ADMINOWNER} "${admpar}" || return 1
180	fi
181	make_dir ${DIRMODE} ${ADMINOWNER} ${ADMINREP} || return 1
182	return 0
183}
184
185#
186# Returns full path to PPD file that was added to the system.
187#
188# $1	- Full path to source PPD file
189# $2	- PPD file name
190# $3	- Full path to repository
191# $4	- Repository name
192# $5	- Label name
193#
194# Return codes:
195#	0	- File successfully added
196#	1	- Error
197#	2	- Duplicate file already exists
198#
199add_ppd()
200{
201	if debugger ; then
202		set -x
203	fi
204
205	verify_ppd_file "${1}"
206	if [[ $? -ne 0 ]] ; then
207		gettext "invalid PPD file: ${1}" 2>/dev/null
208		return 3
209	fi
210
211	# The destination path can now be set
212	dstlabelpath="${3}/${5}"
213	dstmanufpath="${dstlabelpath}/${modmanuf}"
214	dstpath="${dstmanufpath}/${2}"
215
216	#
217	# If a version (either compressed or not compressed) of the PPD
218	# file exists in the destination in the label/repository,
219	# then just return as there no work to be done.
220	dst_copy_path=$(variant_copy "${1}" "${dstpath}" "${6}" "${ppdfname}")
221	ap_rc=$?
222	if [[ ${ap_rc} -ne 0 ]] ; then
223		echo "${dst_copy_path}"
224		return ${ap_rc}
225	fi
226
227	#
228	# Can only add a PPD file to the "user" or "admin" repository.
229	# Note: this check is here instead of at the top of this
230	# function as we don't want to cause an error if a user
231	# specifies the same repository and label as a the specified
232	# ppd file and the repository of the specified ppd file
233	# exists in a known repository.
234	#
235	if [[ "${4}" != "${USER}" && "${4}" != "${ADMIN}" ]] ; then
236		gettext "invalid PPD file repository name: ${4}" 2>/dev/null
237		return 3
238	fi
239
240	# Ensure destination directories exist
241	if ! create_adminrep_dirs ${4} ${DIRMODE} ${ADMINOWNER} || \
242	    ! make_dir ${DIRMODE} ${DIROWNER} "${3}" || \
243	    ! make_dir ${DIRMODE} ${DIROWNER} "${dstlabelpath}" || \
244	    ! make_dir ${DIRMODE} ${DIROWNER} "${dstmanufpath}" ; then
245		gettext "unable to create destination directories" 2>/dev/null
246		return 3
247	fi
248
249	# Copy source PPD file, and compress if needed, to destination
250	if [[ "${ppdfileext}" = "${PEXT}" ]] ; then
251		${GZIP} "${1}" >"${dst_copy_path}" 2>/dev/null
252		if [[ $? -eq 1 ]] ; then
253			gettext "unable to copy PPD file " 2>/dev/null
254			gettext "to destination" 2>/dev/null
255			return 3
256		fi
257	else
258		/bin/cp -f "${1}" "${dst_copy_path}" >/dev/null 2>&1
259		if [[ $? -ne 0 ]] ; then
260			gettext "unable to copy PPD file " 2>/dev/null
261			gettext "to destination" 2>/dev/null
262			return 3
263		fi
264	fi
265	set_perms ${FILEMODE} ${FILEOWNER} "${dst_copy_path}"
266
267	echo "${dst_copy_path}"
268
269	return 0
270}
271
272#
273# Returns 0 if the cache needs to be modified, otherwise
274# returns 1.
275#
276# $1	- Full path to cache
277# $2	- Full path to cache replacement candidate
278#
279changes_in_cache()
280{
281	if debugger "changes_in_cache" ; then
282		set -x
283	fi
284
285	if [[ "${action}" = "${REBUILD}" ]] ; then
286		return 0
287	fi
288	[[ "${2}" -nt "${1}" ]] || return 1
289	if $(${CMP} "${1}" "${2}" >/dev/null 2>&1) ; then
290		# No differences.  Just update timestamp
291		/bin/touch -r "${2}" "${1}" >/dev/null 2>&1
292		return 1
293	else
294		return 0
295	fi
296}
297
298#
299# Generate a new golden cache file (/var/lp/ppd/ppdcache),  by
300# concatenating and sorting all existing cache files in /var/lp/ppd/caches.
301#
302# If there are difference between the newly generated golden cache file and
303# the existing one (if it exists) then the newly generated one replaces the
304# existing one at /var/lp/ppd/ppdcache.
305#
306update_golden_cache()
307{
308
309	if debugger "update_golden_cache" ; then
310		set -x
311	fi
312
313	#
314	# Remove any cache files that don't have an associated
315	# label.
316	#
317	for cname in $(/bin/ls ${VARCACHES} 2>/dev/null) ; do
318		repname="${cname%%:*}"
319		cfile="${cname#*:}"
320		checkdir="$(get_rep_path ${repname})/${cfile}"
321		remove_unassociated_cache "${checkdir}" "${cname}"
322	done
323
324	#
325	# Combine the contents of all cache files into a
326	# temporary golden cache file.
327	#
328	tmpgoldencache=$(/bin/mktemp -p "${ppdmgrtmpdir}" \
329	    tmpgoldencache.XXXXXX 2>/dev/null)
330	/bin/sort "${VARCACHES}"/* >>"${tmpgoldencache}" 2>/dev/null
331
332	if [[ ! -s "${tmpgoldencache}" ]] ; then
333		# No cache files. Remove golden cache.
334		/bin/rm -f "${GOLDCACHE}" >/dev/null 2>&1
335		/bin/rm -f "${tmpgoldencache}" >/dev/null 2>&1
336	elif [[ -e "${GOLDCACHE}" ]] ; then
337		#
338		# Use the newly generated "temporary" golden cache file if there
339		# differences between the current and newly generated ppdcache
340		# or if a rebuild is being performed.
341		#
342		if [[ "${VARCACHES}" -nt "${GOLDCACHE}" ]] || \
343		    changes_in_cache "${GOLDCACHE}" "${tmpgoldencache}" ; then
344			set_perms ${FILEMODE} ${FILEOWNER} "${tmpgoldencache}"
345			/bin/mv -f "${tmpgoldencache}" \
346			    "${GOLDCACHE}" >/dev/null 2>&1
347		else
348			/bin/rm -f "${tmpgoldencache}" >/dev/null 2>&1
349		fi
350	else
351		# There wasn't an existing ppdcache.  Install the newly
352		# generated ppdcache file to the golden ppdcache.
353		set_perms ${FILEMODE} ${FILEOWNER} "${tmpgoldencache}"
354		/bin/mv -f "${tmpgoldencache}" "${GOLDCACHE}" >/dev/null 2>&1
355	fi
356}
357
358#
359# Returns a list of PPD files that exist.
360#
361# $1	- Full path to cache file
362#
363remove_invalid_cache_entries()
364{
365	if debugger ; then
366		set -x
367	fi
368
369	[[ -s "${1}" ]] || return
370
371	IFS="$NoSpaceTabIFS"
372	for centry in $(/bin/cat "${1}" 2>/dev/null) ; do
373		IFS="$SaveIFS"
374		#
375		# Keep the entry from the ppd cache if it still
376		# exists and there haven't been any modifications
377		# since the last update to the cache.
378		#
379		if [[ -n "${centry}" ]] ; then
380			ppdfile="${centry##*:}"
381			if [[ -n "${ppdfile}" && -e "${ppdfile}"  &&
382			    "${1}" -nt "${ppdfile}" ]] ; then
383				echo "${centry}"
384			fi
385		fi
386		IFS="$NoSpaceTabIFS"
387	done
388	IFS="$SaveIFS"
389}
390
391#
392# Returns 0 if the path to the PPD is as follows:
393#	<PPD file repository>/<label>/<manufacturer>/<PPD file>
394# otherwise, returns 1
395#
396# $1	 Full path to PPD file
397#
398verify_ppd_location()
399{
400	if debugger ; then
401		set -x
402	fi
403
404	 #
405	 # Strip off what should be <label>/<manufacturer>/<PPD file>
406	 # and verify the PPD file repository matches one of the
407	 # known PPD file repositories.
408	 #
409	ppd_file_repository=${1%/*/*/*}
410	found=1
411	for repository in ${REPOSITORIES} ; do
412		if [[ "${repository}" = "${ppd_file_repository}" ]] ; then
413			found=0
414			break
415		fi
416	done
417	return ${found}
418}
419
420#
421# Generate, and sort, cache entries for each PPD files in the specified
422# list to the specified file.
423#
424# $1	- List of full paths to PPD files
425# $2	- Full path to current cache file
426# $3	- Full path to label
427# $4	- Full path to new cache file to generate
428#
429# Return code:
430#	0 success
431#	1 unsuccessful
432#
433generate_label_cache_file()
434{
435	if debugger ; then
436		set -x
437	fi
438
439	#
440	# Generate a cache file containing cache entries for
441	# all files in the label.
442	#
443	ucfile=$(/bin/mktemp -p "${ppdmgrtmpdir}" \
444	    unsortedcache.XXXXXX 2>/dev/null)
445
446	#
447	# Before processing new files, remove any cache entries
448	# which may be invalid.
449	#
450	valid_files=
451	if [[ -e "${2}" && "${action}" != "${REBUILD}" ]] ; then
452		valid_files=$(remove_invalid_cache_entries "${2}")
453		if [[ -n "${valid_files}" ]] ; then
454			echo "${valid_files}" >>${ucfile}
455		fi
456	fi
457
458	#
459	# If there are no valid PPD files in the current cache file,
460	# and there are no new PPD files to process, the only thing
461	# left to do is to remove the current cache file.
462	#
463	if [[ -z "${valid_files}" && -z "${1}" ]] ; then
464		/bin/rm -f "${2}" >/dev/null 2>&1
465		/bin/rm -f "${ucfile}" >/dev/null 2>&1
466		return 0
467	fi
468
469	#
470	# For each of the label's PPD files, generate
471	# a cache file entry and add it to the cache file.
472	#
473	vpl_rc=0
474	vpf_rc=0
475	vpl_msg=
476	vpf_msg=
477	IFS="$NoSpaceTabIFS"
478	for fname in ${1} ; do
479		IFS="$SaveIFS"
480		if [[ -n "${fname}" ]] ; then
481			verify_ppd_location "${fname}"
482			vpl_rc=$?
483			if [[ ${vpl_rc} -ne 0 ]] ; then
484				vpl_msg="${vpl_msg}\t${fname}\n"
485			fi
486
487			verify_ppd_file "${fname}"
488			vpf_rc=$?
489			if [[ ${vpf_rc} -ne 0 ]] ; then
490				vpf_msg="${vpf_msg}\t${fname}\n"
491			fi
492
493			if [[ ${vpl_rc} -eq 0 && ${vpf_rc} -eq 0 ]] ; then
494				echo "$(generate_cache_file_entry \
495				    "${modmanuf}" "${model}" "${nickn}" \
496				    "${devidmfg}" "${devidmdl}" "${fname}")"
497			fi
498		fi
499		IFS="$NoSpaceTabIFS"
500	done >>"${ucfile}"
501	IFS="$SaveIFS"
502	/bin/sort -u "${ucfile}" >>"${4}" 2>/dev/null
503	/bin/rm -f "${ucfile}" >/dev/null 2>&1
504
505	[[ -n "${vpl_msg}" || -n "${vpf_msg}" ]] || return 0
506	if [[ -n ${vpl_msg} ]] ; then
507		gettext "  PPD file(s) not in valid location\n" 2>/dev/null
508		gettext \
509	    "  (<repository>/<label>/<manufacturer>/<PPD file>):\n" 2>/dev/null
510		echo "${vpl_msg}"
511	fi
512	if [[ -n ${vpf_msg} ]] ; then
513		gettext "  invalid PPD file(s):\n" 2>/dev/null
514		echo "${vpf_msg}"
515	fi
516	return 1
517}
518
519#
520# Update current cache file with candidate cache file if there are
521# differences.
522#
523# $1	- Current cache file
524# $2	- Candidate cache file to update
525# $3	- Repository name
526#
527update_current_cache_file()
528{
529	if debugger "update_current_cache_file" ; then
530		set -x
531	fi
532
533	if [[ ! -s "${2}" ]] ; then
534		#
535		# Candidate cache has zero size (label
536		# directory with no PPD files under it).
537		# Delete the empty candidate cache
538		# file and delete the current cache
539		# file.
540		#
541		/bin/rm -f "${1}" >/dev/null 2>&1
542		/bin/rm -f "${2}" >/dev/null 2>&1
543	elif [[ -e "${1}" ]] ; then
544		#
545		# If there are differences between the current
546		# cache file and the newly generated one, then
547		# replace the current one with the new one, and
548		# set the flag to update the golden ppdcache
549		# file.
550		#
551		if changes_in_cache "${1}" "${2}" ; then
552			set_perms ${FILEMODE} ${FILEOWNER} "${2}"
553			/bin/mv -f "${2}" "${1}" >/dev/null 2>&1
554		else
555			/bin/rm -f "${2}" >/dev/null 2>&1
556		fi
557	else
558
559		#
560		# There is no current cache file.  Move the candidate
561		# to the caches directory.
562		#
563		set_perms ${FILEMODE} ${FILEOWNER} "${2}"
564		/bin/mv -f "${2}" "${1}" >/dev/null 2>&1
565	fi
566}
567
568#
569# Returns 0 if there are files in $1 with newer timestamp
570# than $2 or if deletions have occurred under $1,
571# otherwise returns 1.
572#
573# $1	- Full path to the destination label
574# $2	- Full path to label cache file
575#
576changes_under_label()
577{
578	if debugger ; then
579		set -x
580	fi
581
582	# First check for newer files in the directory
583	if [[ -e "${2}" && "${action}" != "${REBUILD}" ]] ; then
584		newfiles=$(/bin/find "${1}" -type f -newer "${2}")
585	else
586		newfiles=$(/bin/find "${1}" -type f)
587	fi
588	echo "${newfiles}"
589	[[ -z "${newfiles}" ]] || return 0
590
591	#
592	# Need to detect if PPD files have been deleted by checking
593	# timestamps on label and manufacturer directories.
594	#
595	[[ ! "${1}" -nt "${2}" ]] || return 0
596	/bin/find "${1}" -type d -newer "${2}" >/dev/null 2>&1 || return 1
597	return 0
598}
599
600#
601# If -R was specified, or the timestamp on the specified label's
602# directory or any of the PPD files under the specified label in
603# the specified PPD file respository is newer than the cache file
604# associated with the label, then generate a new sorted cache file.
605#
606# The new cache will replace the existing one (if any) only if there
607# are differences.  Note: if -r was specified, then a new cache file
608# file will always be installed at
609#	/var/lp/ppd/caches/<PPD file repository name>-<label name>
610#
611# $1	- Full path of the destination PPD file repository
612# $2	- Destination PPD file repository name
613# $3	- Destination label name
614#
615update_label_cache()
616{
617	if debugger ; then
618		set -x
619	fi
620
621	dstlabelpath="${1}/${3}"
622	replabelcachepath="${1}/${CACHES}/${3}"
623	varlabelcachepath="${VARCACHES}/${2}${SEP}${3}"
624
625	ulc_rc=0
626	if [[ -d "${dstlabelpath}" ]] ; then
627
628		#
629		# If the cache doesn't exist for a label,
630		# or if there were any changes under a label
631		# (i.e., the timestamp on the label directory or any
632		# of the PPD files under it is newer than the
633		# existing cache file), then generate a new cache file.
634		#
635		tmpcachepath=$(/bin/mktemp -p "${ppdmgrtmpdir}" \
636		    tmpcachepath.XXXXXX 2>/dev/null)
637
638		# if this is a system repository, check for a prepopulated cache
639		if [[ "${2}" = "${SYSTEM}" && -e ${FOOCACHEDIR}/${3}.cache ]] ; then
640			# copy prepopulated cache
641			/bin/cp -f ${FOOCACHEDIR}/${3}.cache ${tmpcachepath}
642
643		else
644			newfileslist=$(changes_under_label "${dstlabelpath}" \
645			    "${varlabelcachepath}")
646			if [[ $? -eq 0 ]] ; then
647				err_files=$(generate_label_cache_file \
648				    "${newfileslist}" "${varlabelcachepath}" \
649				    "${dstlabelpath}" "${tmpcachepath}")
650				if [[ $? -ne 0 ]] ; then
651					#
652					# At least one PPD file was invalid.
653					# Don't return yet, as the cache info
654					# for the valid PPD files can still be
655					# used to generate a cache file.
656					#
657					echo "${err_files}"
658					ulc_rc=1
659				fi
660			fi
661		fi
662
663		if [[ -e "${tmpcachepath}" ]] ; then
664			update_current_cache_file \
665			    "${varlabelcachepath}" "${tmpcachepath}" "${2}"
666			/bin/rm -f "${tmpcachepath}" >/dev/null 2>&1
667		fi
668	else
669		#
670		# If there is a cache file in /var/lp/ppd/caches associated
671		# with the label which no longer exists, remove it.
672		#
673		/bin/rm -f "${varlabelcachepath}" >/dev/null 2>&1
674	fi
675	return ${ulc_rc}
676}
677
678#
679# Returns the alias for the specified real manufacturer's name.
680#
681# $1	- Real manufacturer's name
682# $2	- File containing list of files that have manufacturers aliases
683#
684manuf_name_alias()
685{
686	if debugger ; then
687		set -x
688	fi
689
690	#
691	# Found a couple of PPD files which had special characters
692	# in the Manufacturer name (i.e, the following is the Manufacturer
693	# entry:
694	#	*Manufacturer:  "Canon Inc. (Kosugi Offic"
695	# We'll only search the alias file for "Canon Inc."
696	#
697	tmpmanuf="${1% *\(*}"
698
699	# Search alias files for a match on the real manufacturer name
700	if [[ -s "${2}" ]] ; then
701		#
702		# Check the manufacturer aliases file for case
703		# insensitive match of the Manufacturer entry
704		# from the PPD file.  If a match is found,
705		# then modify the manufacturer entry to
706		# be that of the specified alias.
707		#
708		manufaliases=$(/bin/egrep -i \
709		    "^${tmpmanuf}:|:${tmpmanuf}:|:${tmpmanuf}$" "${2}")
710		if [[ -n "${manufaliases}" ]] ; then
711			echo "${manufaliases%%:*}"
712			break
713		else
714			echo "${tmpmanuf}"
715		fi
716	else
717		echo "${tmpmanuf}"
718	fi
719}
720
721#
722# Returns 0 if the extension to the specified PPD file is a known
723# extension, otherwise returns 1.
724#
725# $1	- Full path to PPD file
726#
727# Set upon return:
728#	ppdfileext	- PPD file ext (.ppd or .ppd.gz)
729#
730verify_file_ext()
731{
732	if debugger ; then
733		set -x
734	fi
735
736	if [[ "${1%.gz}".gz = "${1}" ]] ; then
737		ppdfileext=${GEXT}
738	elif [[ "${1%.ppd}".ppd = "${1}" ]] ; then
739		ppdfileext=${PEXT}
740	else
741		# invalid PPD file name extension
742		return 1
743	fi
744
745	return 0
746}
747
748#
749# Return the lines from the specified PPD file matching the specified
750# spec items.
751#
752# $1	- spec entries from PPD file
753# $2	- spec item
754#
755# $1 example - 1 string with substrings separated by newline:
756#	*PPD-Adobe: "4.3"
757#	*Manufacturer: "HP"
758#	*Product:       "(officejet 4200 series)"
759#	*ModelName:     "HP OfficeJet 4200"
760#	*NickName:      "HP OfficeJet 4200 Foomatic/hpijs (recommended)"
761# $2 example:
762#	^\*Manufacturer
763#
764spec_entry()
765{
766	if debugger ; then
767		set -x
768	fi
769
770	item=$(echo "${1}" | /bin/grep ${2})
771	# Remove everything up to and including the first quote
772	item=${item#*\"}
773	# Remove the end quote
774	echo "${item%\"}"
775}
776
777#
778# Return the lines from the specified PPD file matching the specified
779# spec items.
780#
781# Note: this is similar to spec_entry() except the tokens in the
782# spec entry are different.
783#
784# $1	- spec entries from PPD file
785# $2	- spec item
786#
787devid_spec_entry()
788{
789	if debugger ; then
790		set -x
791	fi
792
793	item=$(echo "${1}" | /bin/grep ${2})
794	# Remove everything up to and including the first semi-colon
795	item=${item#*\:}
796	# Remove the end quote
797	echo ${item%\;}
798
799}
800
801#
802# Verifies that the specified PPD file
803#	- has a valid extension
804#	- has the following required spec file entries:
805#		*PPD-Adobe: "4.3"
806#		Manufacturer
807#		Product
808#		ModelName
809#		NickName
810#
811# In addition, the manufacture and model from the IEEE1284 device id
812# information will be gathered here, although it's not an error that
813# it isn't in the PPD file as many don't contain the IEEE1284 info.
814#
815# $1	- Full path to PPD file
816#
817# Return codes:
818#	0	success
819#	1	invalid PPD file
820#
821verify_ppd_file()
822{
823	if debugger ; then
824		set -x
825	fi
826
827	ADOBESPEC="PPD-Adobe"
828	MANUF="Manufacturer"
829	PRODUCT="Product"
830	MODEL="ModelName"
831	NICKNAME="NickName"
832	DEVID="1284DeviceID"
833
834	# Verify the PPD file extension
835	verify_file_ext "${1}" || return 1
836
837	# Query for the required spec items
838	searchentries="^\*${ADOBESPEC}:|^\*${MANUF}:|^\*${PRODUCT}:"
839	searchentries="${searchentries}|^\*${MODEL}:|^\*${NICKNAME}:"
840	searchentries="${searchentries}|^\*${DEVID}:"
841	ppd_info="$(/bin/gzgrep -e "${searchentries}" "${1}")"
842
843	#
844	# Process the query results to verify each of the required spec
845	# file items appears in the PPD file.
846	#
847	for spec_item in ${ADOBESPEC} ${MANUF} ${PRODUCT} ${MODEL} \
848	    ${NICKNAME} ; do
849		entry=$(spec_entry "${ppd_info}" "^\*${spec_item}:")
850		[[ ! -z "${entry}" ]] || return 1
851		case ${spec_item} in
852		${MANUF})
853			realmanuf="${entry}"
854			;;
855		${PRODUCT})
856			product="${entry}"
857			;;
858		${MODEL})
859			model="${entry}"
860			;;
861		${NICKNAME})
862			#
863			# Remove the model and any commas and spaces
864			# which appear before the driver
865			#
866			nickn="${entry#$model[, ]*}"
867			;;
868		esac
869
870	done
871
872	# Save IEEE1284 device id information
873	if $(echo "${ppd_info}" | grep "${DEVID}" >/dev/null 2>&1) ; then
874		DMDL="MDL"
875		DMFG="MFG"
876		devid="$(/bin/gzgrep -e "^[ ]*${DMDL}:|^[ ]*${DMFG}:" "${1}")"
877		devidmdl="$(devid_spec_entry "${devid}" "${DMDL}")"
878		devidmfg="$(devid_spec_entry "${devid}" "${DMFG}")"
879	else
880		devidmdl=
881		devidmfg=
882	fi
883	modmanuf=$(manuf_name_alias "${realmanuf}" ${aliasfile})
884
885	return 0
886}
887
888#
889# generate_cache_file_entry()
890#
891# Returns a cache file entry for the specified PPD file.
892#
893# $1	- modmanuf
894# $2	- model
895# $3	- nickn
896# $4	- devidmfg
897# $5	- devidmdl
898# $6	- Full path to the specified PPD file
899#
900generate_cache_file_entry()
901{
902	if debugger "generate_cache_file_entry" ; then
903		set -x
904	fi
905
906	echo "${1}":"${2}":"${3}":"${4}":"${5}":"${6}"
907}
908
909#
910# Expand specified file to the full path.
911#
912# $1	- File path to expand
913#
914# Return code set to 0 if expanded successfully, otherwise set to 1.
915#
916ppd_pathname()
917{
918	if debugger ; then
919		set -x
920	fi
921
922	if [[ -f "${1}" && -s "${1}" ]] ; then
923		(cd "$(/bin/dirname "${1}")" ; \
924		    echo "$(/bin/pwd)/$(/bin/basename "${1}")") || return 1
925		return 0
926	else
927		return 1
928	fi
929}
930
931#
932# Returns the PPD repsitory path associated with the specified
933# PPD repository name.
934#
935# $1	- Repository name
936#
937get_rep_path()
938{
939	if debugger ; then
940		set -x
941	fi
942
943	case ${1} in
944	${SYSTEM})
945		echo "${SYSTEMREP}"
946		;;
947	${VENDOR})
948		echo "${VENDORREP}"
949		;;
950	${ADMIN})
951		echo "${ADMINREP}"
952		;;
953	${USER})
954		echo "${USERREP}"
955		;;
956	*)
957		echo "${UNSET}"
958		;;
959	esac
960}
961
962#
963# Returns the PPD respository name from the repository path
964#
965# $1	- PPD repository path
966#
967get_rep_name()
968{
969	if debugger ; then
970		set -x
971	fi
972
973	case ${1} in
974	${SYSTEMREP})
975		echo "${SYSTEM}"
976		;;
977	${VENDORREP})
978		echo "${VENDOR}"
979		;;
980	${ADMINREP})
981		echo "${ADMIN}"
982		;;
983	${USERREP})
984		echo "${USER}"
985		;;
986	"all")
987		echo "all"
988		;;
989	*)
990		echo "${UNSET}"
991		;;
992	esac
993}
994
995#
996# Returns 0 if a matching label name is found in the specified repository,
997# otherwise returns 1.
998#
999# $1	- repository path
1000# $2	- label name
1001#
1002label_path_in_repository()
1003{
1004	if debugger "label_path_in_repository" ; then
1005		set -x
1006	fi
1007
1008	[[ "${1}" != "" && "${2}" != "" ]] || return 1
1009	lpir_rc=1
1010	for repository in ${REPOSITORIES} ; do
1011		if [[ "${repository}" = "${1}" && -d "${1}/${2}" ]] ; then
1012			lpir_rc=0
1013			break
1014		fi
1015	done
1016	return ${lpir_rc}
1017}
1018
1019#
1020# Returns 0 if the source label path is the same
1021# as the destination label path, otherwise returns 1.
1022#
1023# $1	- full path to source PPD file (source label path)
1024# $2	- destination repository path
1025# $3	- destination label name
1026#
1027label_path_match()
1028{
1029	if debugger "label_path_match" ; then
1030		set -x
1031	fi
1032
1033	# dest repository not specified
1034	if [[ "${2}" = "${UNSET}" ]] ; then
1035		# dest label not specified
1036		if [[ "${3}" = "${UNSET}" ]] ; then
1037			#
1038			# We've found a match if the label path is in a known
1039			# repository.
1040			#
1041			lpath="${1%/*/*}"
1042			label_path_in_repository \
1043			    "${1%/*/*/*}" "${lpath##*/}" || return 1
1044		else
1045			#
1046			# If the source label path exists in the
1047			# in a known repository, and the destination
1048			# label is the same as the source label,
1049			# then we'll assume the default destination
1050			# repository is the same as the source
1051			# destination repository.
1052			#
1053			[[ "${1%/*/*}" = "${1%/*/*/*}/${3}" ]] || return 1
1054			label_path_in_repository "${1%/*/*/*}" "${3}" || \
1055			    return 1
1056		fi
1057
1058	# dest repository specified, dest label not specified
1059	elif [[ "${3}" = "${UNSET}" ]] ; then
1060		#
1061		# If the destination repository path is the same as the
1062		# source repository, and if the source label exists in the
1063		# destination repository path, then we'll assume the default
1064		# destination label is the same as the source label.
1065		#
1066		[[ "${2}" = "${1%/*/*/*}" ]] || return 1
1067		lpath="${1%/*/*}"
1068		label_path_in_repository "${2}" "${lpath##*/}" || return 1
1069
1070	# dest repository and dest label specified.
1071	else
1072		#
1073		# We've found a match if the destination and label
1074		# match those of the source label path, and the source
1075		# label path is in a known repository.
1076		#
1077		[[ "${1%/*/*}" = "${2}/${3}" ]] || return 1
1078		label_path_in_repository "${2}" "${3}" || return 1
1079	fi
1080	return 0
1081}
1082
1083#
1084# Returns 0 if specified label name is a reserved label, otherwise
1085# returns 1.
1086#
1087# $1	- label name
1088#
1089reserved_label()
1090{
1091	if debugger ; then
1092		set -x
1093	fi
1094
1095	rl_rc=1
1096	for labelname in ${RESERVEDLABELS} ; do
1097		if [[ "${1}" = "${labelname}" ]] ; then
1098			rl_rc=0
1099			break
1100		fi
1101	done
1102	return ${rl_rc}
1103}
1104
1105#
1106# Returns a list of all labels that exist in a repository that are
1107# not reserved labels.
1108#
1109# $1	- Full path of repository
1110# $2	- Repository name
1111#
1112get_rep_label_list()
1113{
1114	if debugger ; then
1115		set -x
1116	fi
1117
1118	#
1119	# Get a list of all labels that exist in all of the
1120	# PPD file repository.
1121	#
1122	for lname in $(/bin/ls "${1}" 2>/dev/null) ; do
1123		if [[ -d "${1}/${lname}" ]] ; then
1124			if ! reserved_label "${lname}" ; then
1125				echo "${lname} "
1126			fi
1127		fi
1128	done
1129}
1130
1131#
1132# Returns a valid PPD label.
1133#
1134# Verifies the specified PPD label is a valid label.  If the
1135# label is not set, then it is set to a default value.
1136#
1137# Return code set to 0 if the specified PPD label is valid, otherwise 1.
1138#
1139# $1	- PPD label
1140#
1141valid_specified_label()
1142{
1143	if debugger ; then
1144		set -x
1145	fi
1146
1147	# Verify the specified label
1148	vsl_rc=0
1149	case "${1}" in
1150	"all")
1151		# Reserved label name with -a or -g options
1152		if [[ "${action}" = "${ADD}" || \
1153		    "${action}" = "${GENERATEENTRY}" ]] ; then
1154			print -n "$myprog: " 1>&2
1155			gettext "reserved PPD label name: ${1}\n" 1>&2
1156			vsl_rc=1
1157		else
1158			echo "${1}"
1159		fi
1160		;;
1161
1162	"ppdcache" | "caches" | "manufaliases")
1163		# Reserved label names with any option
1164		print -n "$myprog: " 1>&2
1165		gettext "reserved PPD label name: ${1}\n" 1>&2
1166		vsl_rc=1
1167		;;
1168
1169	"" | "${UNSET}")
1170		# Label name not specified.  Set the default label name.
1171		# For -g and -a, default is "user", otherwise, default
1172		# is "all".
1173		if [[ "${action}" = "${ADD}" || \
1174		    "${action}" = "${GENERATEENTRY}" ]] ; then
1175			echo "${USER}"
1176		else
1177			echo "all"
1178		fi
1179		;;
1180
1181	*)
1182		# label cannot be "." or ".."
1183		if [[ "${1}" = "." || "${1}" = ".." ]] ; then
1184			print -n "$myprog: " 1>&2
1185			gettext "PPD label name cannot be " 1>&2
1186			gettext "\".\" or \"..\"\n" 1>&2
1187			vsl_rc=1
1188		fi
1189
1190		# Label name cannot contain special characters
1191		echo "${1}" | /bin/egrep "${SPECIALCHARS}" >/dev/null
1192		if [[ $? -eq 0 ]] ; then
1193			print -n "$myprog: " 1>&2
1194			gettext "PPD label name contains " 1>&2
1195			gettext "an invalid character: ${1}\n" 1>&2
1196			vsl_rc=1
1197		else
1198			echo "${1}"
1199		fi
1200		;;
1201	esac
1202	return ${vsl_rc}
1203}
1204
1205#
1206# Returns the full path of any variant copy of the source file in
1207# the destination label/repository.
1208#
1209# $1	- Full path to source PPD file
1210# $2	- Full path to destination PPD file
1211#
1212# Return code set to
1213#	0	- Copy doesn't exist
1214#	1	- Duplicate copy exists
1215#	2	- Variant copy exists
1216#
1217variant_copy()
1218{
1219	if debugger ; then
1220		set -x
1221	fi
1222
1223	#
1224	# First make sure there is not a .ppd and a .ppd.gz version
1225	# of the destination file; users should know not to do this.
1226	#
1227	if [[ -e "${2%.gz}" && -e "${2%.gz}.gz" ]] ; then
1228		/bin/rm -f "${2%.gz}" >/dev/null 2>&1
1229	fi
1230
1231	# Use gzcmp to compare PPD files as it can deal with
1232	# gzipped or regular files.
1233	if $(${GZCMP} "${1}" "${2}"* >/dev/null 2>&1) ; then
1234		echo "${2}"*
1235		return 1
1236	elif [[ -e "${2%.gz}" ]] ; then
1237		echo "${2%.gz}"
1238		return 2
1239	elif [[ -e "${2%.gz}.gz" ]] ; then
1240		echo "${2%.gz}.gz"
1241		return 2
1242	else
1243		#
1244		# A PPD file doesn't exist in the destination
1245		# repository under the destination label.
1246		# Just display the source PPD file, ensuring
1247		# it has a gzip extension as we will always
1248		# try to gzip the copy in the destination.
1249		#
1250		if [[ "${1#*.ppd}" = ".gz" ]] ; then
1251			echo "${2}"
1252		else
1253			echo "${2}.gz"
1254		fi
1255		return 0
1256	fi
1257}
1258
1259#
1260# $1	- Directory mode
1261# $2	- Directory owner (i.e., root:lp)
1262# $3	- Directory to create
1263#
1264make_dir()
1265{
1266	if debugger "make_dir" ; then
1267		set -x
1268	fi
1269
1270	[[ ! -d "${3}" ]] || return 0
1271	/bin/mkdir "${3}" >/dev/null 2>&1 || return 1
1272	set_perms ${1} ${2} "${3}"
1273	return 0
1274}
1275
1276#
1277# Remove a ppdmgr generated cache (in /var/lp/ppd/cache)
1278# if it doesn't have an associated label in the repository.
1279#
1280# $1	- Full path to label
1281# $2	- Cache name
1282#
1283remove_unassociated_cache()
1284{
1285	if debugger "remove_unassociated_cache" ; then
1286		set -x
1287	fi
1288
1289	if [[ "${1}" != "${UNSET}" ]] ; then
1290		if [[ -n "${1}" && ! -d "${1}" ]] ; then
1291			#
1292			# The label doesn't exist, so delete
1293			# the associated cache file.
1294			#
1295			/bin/rm -f "${VARCACHES}/${2}" >/dev/null 2>&1
1296		fi
1297	fi
1298}
1299
1300#
1301# Sorted copies of cache files for each label in each PPD repository
1302# are maintained in /var/lp/ppd/caches/<PPD respository>-<label>.
1303# This is done so that changes in delivered cache files can be
1304# detected.  If a difference in cache files is detected, or a
1305# cache file is either added or removed, then we know that
1306# the ppdcache file needs to be updated.
1307#
1308# Get a list of all cache files and compare against the list
1309# of labels in all of the PPD file repositories.  They should
1310# be the same.  If there is a label in one of the PPD file
1311# repositories that doesn't have an associated cache file, then
1312# we don't worry about it now, as that will be resolved when
1313# we update the cache for that label.  However, if there is
1314# a cache file associated with a label that no longer exists, then
1315# remove the cache file.
1316#
1317# $1	- Full path to repository (or "all")
1318# $2	- Label name
1319#
1320update_cache()
1321{
1322	if debugger ; then
1323		set -x
1324	fi
1325
1326	#
1327	# Determine which labels in which PPD repository the
1328	# cache file will be updated for.
1329	#
1330	if [[ "${1}" = "all" ]] ; then
1331		rname="${REPOSITORIES}"
1332	else
1333		rname="${1}"
1334	fi
1335
1336	uc_rc=0
1337	for dstreppath in ${rname} ; do
1338		labellist=
1339		if [[ "${2}" = "all" ]] ; then
1340			dstrepname=$(get_rep_name "${dstreppath}")
1341			labellist=$(get_rep_label_list "${dstreppath}" \
1342			    "${dstrepname}")
1343		else
1344
1345			# Ensure the label exists in the PPD file repository.
1346			if [[ -d "${dstreppath}/${2}" ]] ; then
1347				labellist="${2}"
1348			fi
1349		fi
1350
1351		#
1352		# Update the cache for each label in the PPD repository
1353		#
1354		for dstlabel in ${labellist} ; do
1355			ulc_msg=$(update_label_cache "${dstreppath}" \
1356			    "${dstrepname}" "${dstlabel}")
1357			if [[ $? -ne 0 ]] ; then
1358				echo "${ulc_msg}"
1359				uc_rc=1
1360			fi
1361		done
1362	done
1363
1364	# Update the golden cache file.
1365	update_golden_cache
1366	return ${uc_rc}
1367}
1368
1369# $1	- exit status
1370ppdmgr_exit()
1371{
1372	if debugger "ppdmgr_exit" ; then
1373		set -x
1374	fi
1375
1376	/bin/rm -rf "${ppdmgrtmpdir}" >/dev/null 2>&1
1377	exit ${1}
1378}
1379
1380
1381usage()
1382{
1383	gettext "usage:\n" 1>&2
1384	print -n "\t$myprog: " 1>&2
1385	gettext "-a <ppd_filename_path> [ -L <label> ]\n" 1>&2
1386	gettext "\t\t[ -R <ppd_repository> ] [-w]\n" 1>&2
1387	print -n "\t$myprog: " 1>&2
1388	gettext "-r [ -L <label> ] [ -R <ppd_repository> ]\n" 1>&2
1389	print -n "\t$myprog: " 1>&2
1390	gettext "-u [ -L <label> ] [ -R <ppd_repository> ]\n" 1>&2
1391
1392	ppdmgr_exit ${FAIL}
1393}
1394
1395##########################################################################
1396# main
1397##########################################################################
1398
1399myprog=$(/bin/basename $0)
1400
1401SaveIFS="$IFS"
1402NoSpaceTabIFS='
1403'
1404
1405# Updatable PPD repository
1406VARDIR=/var/lp/ppd
1407
1408# Delivered PPD respository
1409SYSTEMREP=/usr/share/ppd
1410ADMINREP=/usr/local/share/ppd
1411VENDORREP=/opt/share/ppd
1412USERREP=${VARDIR}
1413
1414RESERVEDREPS="${SYSTEMREP} ${ADMINREP} ${VENDORREP}"
1415REPOSITORIES="${USERREP} ${RESERVEDREPS}"
1416RESERVEDLABELS="all caches ppdcache manufaliases"
1417
1418# Directory where system:SUNWfoomatic is delivered
1419FOOCACHEDIR=/usr/lib/lp/caches
1420
1421# Deliveries
1422SYSTEM=system
1423VENDOR=vendor
1424ADMIN=admin
1425USER=user
1426
1427# Sytem PPD cache name used by printmgr
1428GOLDCACHE=${USERREP}/ppdcache
1429
1430# Delivered caches directory
1431CACHES=caches
1432MANUFALIASES=manufaliases
1433
1434# Updated caches directory
1435VARCACHES=${VARDIR}/${CACHES}
1436
1437# valid PPD file name extensions
1438PEXT=ppd
1439GEXT=gz
1440FILEEXTS=".${PEXT} .${PEXT}.${GEXT}"
1441
1442# Default modes and owners
1443DIRMODE=755
1444DIROWNER=root:lp
1445ADMINOWNER=root:root
1446FILEMODE=444
1447FILEOWNER=root:lp
1448
1449# ppdmgr actions
1450ADD=add
1451GENERATEENTRY=generateentry
1452UPDATE=update
1453REBUILD=rebuild
1454
1455SUCCESS=0
1456FAIL=1
1457WARN=2
1458
1459MAXLABELNAME=256
1460GZIP="/bin/gzip -c"
1461GZCMP="/bin/gzcmp -s"
1462CMP="/bin/cmp -s"
1463SPECIALCHARS=":"
1464SEP=":"
1465
1466debug=0
1467wflag=0
1468status=${SUCCESS}
1469
1470UNSET=""
1471ppdlabel=${UNSET}
1472ppdrepname=${UNSET}
1473ppdreppath=${UNSET}
1474modmanuf=
1475model=
1476nickn=
1477devidmdl=
1478devidmfg=
1479
1480ppdmgrtmpdir=/tmp/ppdmgr.$$
1481/bin/mkdir "${ppdmgrtmpdir}" >/dev/null 2>&1
1482set_perms ${DIRMODE} ${DIROWNER} "${ppdmgrtmpdir}"
1483
1484aliasfile=${USERREP}/manufaliases
1485tmpfilepath=
1486
1487
1488OPTS=a:g:L:rR:uwZ
1489while getopts "$OPTS" arg ; do
1490	case ${arg} in
1491	a)	# add PPD file
1492		action=${ADD}
1493		origsrcppdpath=${OPTARG}
1494		;;
1495
1496	g)	# create cache entry
1497		action=${GENERATEENTRY}
1498		origsrcppdpath=${OPTARG}
1499		;;
1500
1501	L)	# PPD label name
1502		ppdlabel=${OPTARG}
1503		;;
1504
1505	r)	# rebuild cache
1506		action=${REBUILD}
1507		;;
1508
1509	R)	# PPD file repository to use
1510		ppdrepname=${OPTARG}
1511		;;
1512
1513	u)	# update cache
1514		action=${UPDATE}
1515		;;
1516
1517	w)	# display PPD file path
1518		wflag=1
1519		;;
1520
1521	Z)	# debug
1522		debug=1
1523		;;
1524
1525	?)
1526		usage
1527		;;
1528	esac
1529done
1530
1531if debugger "Main" ; then
1532	set -x
1533fi
1534
1535if [[ $# -lt 1 || -z "${action}" ]] ; then
1536	usage
1537fi
1538
1539# ignore wflag unless specified with -a
1540if [[ ${wflag} -eq 1 && "${action}" != ${ADD} ]] ; then
1541	wflag=0
1542fi
1543
1544#
1545# Ensure the destination PPD repository directory is set
1546# to match the specified repository.  If the
1547# destination PPD file repository was specified, then
1548# it must be one of the following:
1549# 	"user"
1550#	"admin"
1551#	"vendor"
1552#	"system"
1553#	"all"
1554#
1555case "${ppdrepname}" in
1556"${SYSTEM}")
1557	ppdreppath="${SYSTEMREP}"
1558	;;
1559"${ADMIN}")
1560	ppdreppath="${ADMINREP}"
1561	;;
1562"${VENDOR}")
1563	ppdreppath="${VENDORREP}"
1564	;;
1565"${USER}")
1566	ppdreppath="${USERREP}"
1567	;;
1568"all")
1569	if [[ "${action}" = "${ADD}" || \
1570	    "${action}" = "${GENERATEENTRY}" ]] ; then
1571		print -n "$myprog: " 1>&2
1572		gettext "reserved PPD repository name: " 1>&2
1573		gettext "${ppdrepname}\n" 1>&2
1574		ppdmgr_exit ${FAIL}
1575	fi
1576	ppdreppath="all"
1577	;;
1578"${UNSET}"|"")
1579	ppdreppath="${UNSET}"
1580	;;
1581
1582*)
1583	print -n "$myprog: " 1>&2
1584	gettext "invalid PPD repository name: ${ppdrepname}\n" 1>&2
1585	ppdmgr_exit ${FAIL}
1586	;;
1587esac
1588
1589#
1590# When a source PPD file's path is from a known repository, the
1591# destination repository and desination label are assumed to be the
1592# same as the source PPD file's unless a differing repository or label
1593# was specified.
1594#
1595if [[ "${action}" = "${ADD}" || "${action}" = "${GENERATEENTRY}" ]] ; then
1596
1597	srcppdpath=$(ppd_pathname "${origsrcppdpath}")
1598	ppd_pathname_rc=$?
1599	if [[ ${ppd_pathname_rc} -ne 0 ]] ; then
1600		print -n "$myprog: " 1>&2
1601		gettext "invalid PPD file: ${origsrcppdpath}\n" 1>&2
1602		ppdmgr_exit ${ppd_pathname_rc}
1603	fi
1604
1605	# Path cannot contain special characters
1606	echo "${srcppdpath}" | /bin/egrep  "${SPECIALCHARS}" >/dev/null
1607	if [[ $? -eq 0 ]] ; then
1608		print -n "$myprog: " 1>&2
1609		gettext "PPD path contains " 1>&2
1610		gettext "an invalid character: ${ppd_pathname}\n" 1>&2
1611		ppdmgr_exit ${FAIL}
1612	fi
1613	ppdfname=$(/bin/basename "${origsrcppdpath}")
1614
1615	#
1616	# Check to see if there's any work to be done.  If the source file
1617	# is already in the destination repository under the destination
1618	# label, then there's nothing left to do.  We exit rather than
1619	# going on to do an update on the label in the repository as
1620	# it could possible take a long time to update.  If an add was
1621	# requested, it could have come from an application, so we want
1622	# to return quickly.
1623	#
1624	if label_path_match "${srcppdpath}" "${ppdreppath}" "${ppdlabel}" ; then
1625		if [[ ${wflag} -eq 1 || \
1626		    "${action}" = "${GENERATEENTRY}" ]] ; then
1627			echo "${srcppdpath}"
1628		fi
1629		ppdmgr_exit ${SUCCESS}
1630	fi
1631fi
1632
1633ppdlabel=$(valid_specified_label "${ppdlabel}")
1634if [[ $? -ne 0 ]] ; then
1635	ppdmgr_exit ${FAIL}
1636fi
1637
1638if [[ "${ppdreppath}" = "${UNSET}" ]] ; then
1639	ppdreppath="${USERREP}"
1640fi
1641
1642dstrepname=$(get_rep_name "${ppdreppath}")
1643
1644case "${action}" in
1645"${ADD}")
1646	#
1647	# Attempt to add the PPD file to the repository under the
1648	# specified label.  If any errors occur, final_dst_ppd_path
1649	# will contain the error message rather than the path to the
1650	# PPD file.
1651	#
1652	final_dst_ppd_path=$(add_ppd "${srcppdpath}" "${ppdfname}" \
1653	    "${ppdreppath}" "${dstrepname}" "${ppdlabel}")
1654	add_ppd_rc=$?
1655	case ${add_ppd_rc} in
1656	0)	#
1657		# The PPD file was added.  Update the specified
1658		# cache associated with the label if the PPD file
1659		# was added successfully and was not a duplicate.
1660		# Ensure any changes are also reflected in the
1661		# golden cache.
1662		#
1663		add_ppd_msg=$(update_label_cache "${ppdreppath}" \
1664		    "${dstrepname}" "${ppdlabel}")
1665		apm_rc=$?
1666
1667		echo "${add_ppd_msg}" | /bin/grep "${final_dst_ppd_path}"
1668		path_in_msg=$?
1669
1670		#
1671		# Only report cache update errors if the file that was
1672		# added was one that was reported as not being added
1673		# to the cache.  This really should happen as the file
1674		# was verified during the add.
1675		#
1676		if [[ ${apm_rc} -ne 0 && ${path_in_msg} -eq 0 ]] ; then
1677			print -n "$myprog: " 1>&2
1678			gettext "printer information does not reflect " 1>&2
1679			gettext "the\nfollowing PPD file(s):\n" 1>&2
1680			print "${add_ppd_msg}" 1>&2
1681			status=${FAIL}
1682		else
1683			update_golden_cache
1684
1685			#
1686			# Display the full path to the added PPD file,
1687			# if requested (-w).
1688			#
1689			if [[ ${wflag} -eq 1 ]] ; then
1690				print "${final_dst_ppd_path}"
1691			fi
1692		fi
1693		;;
1694
1695	1)	# Duplicate copy exists
1696		if [[ ${wflag} -eq 1 ]] ; then
1697			print "${final_dst_ppd_path}"
1698		fi
1699		;;
1700
1701	2)	# Varying copy exists
1702		print -n "$myprog: " 1>&2
1703		gettext "differing variant of source PPD file " 1>&2
1704		gettext "already exists at\n" 1>&2
1705		gettext "${final_dst_ppd_path}\n" 1>&2
1706		status=${FAIL}
1707		;;
1708	*)	# The PPD file was not added as a problem occurred.
1709		# Display the error message.
1710		print -n "$myprog: " 1>&2
1711		print "${final_dst_ppd_path}" 1>&2
1712		status=${FAIL}
1713		;;
1714
1715	esac
1716	;;
1717
1718"${GENERATEENTRY}")
1719	#
1720	# Create a cache file entry for the specified PPD file and
1721	# display it on standard out.
1722	#
1723	verify_ppd_file "${srcppdpath}"
1724	if [[ $? -eq 0 ]] ; then
1725		dstdir="${ppdreppath}/${ppdlabel}/${modmanuf}"
1726		final_dst_path="${dstdir}/$(/bin/basename ${srcppdpath})"
1727		verify_ppd_location "${final_dst_path}"
1728		if [[ $? -eq 0 ]] ; then
1729			# Generate the cache file entry
1730			print "$(generate_cache_file_entry "${modmanuf}" \
1731			    "${model}" "${nickn}" "${devidmfg}" "${devidmdl}" \
1732			    "${final_dst_path}")"
1733		else
1734			print -n "$myprog: " 1>&2
1735			gettext "PPD file not in valid location\n" 1>&2
1736			gettext \
1737	    "(<repository>/<label>/<manufacturer>/<PPD file>):\n\t${1}\n" 1>&2
1738			status=${FAIL}
1739		fi
1740
1741	else
1742		print -n "$myprog: " 1>&2
1743		gettext "invalid PPD file: ${1}\n" 1>&2
1744		status=${FAIL}
1745	fi
1746	;;
1747
1748"${REBUILD}" | "${UPDATE}")
1749	update_msg=$(update_cache "${ppdreppath}" "${ppdlabel}")
1750	if [[ $? -ne 0 ]] ; then
1751		print -n "$myprog: " 1>&2
1752		gettext "printer information does not reflect " 1>&2
1753		gettext "the\nfollowing PPD file(s):\n" 1>&2
1754		print "${update_msg}" 1>&2
1755		status=${WARN}
1756	fi
1757	;;
1758
1759*)
1760	usage
1761	;;
1762esac
1763
1764ppdmgr_exit ${status}
1765