77 	 * works. We have to take special handling when the file does exist. To  in file_creat()
78 	 * detect this, we use O_EXCL. For example when trying to create a  in file_creat()
79 	 * file and a character device or fifo exists with the same name, we  in file_creat()
81 	 * open). If we find that the open has failed, then spend the effort  in file_creat()
92 	 * the file seems to exist. First we try to get rid of it (found to be  in file_creat()
94 	 * then we go to the expense to check and create the path to the file  in file_creat()
103 		 * it cannot fix anything, we will skip the last attempt  in file_creat()
137 	 * set owner/groups first as this may strip off mode bits we want  in file_close()
146 	 * if not preserving mode or we cannot set uid/gid, then PROHIBIT  in file_close()
171 	 * we may be running as root, so we have to be sure that link target  in lnk_creat()
172 	 * is not a directory, so we lstat and check  in lnk_creat()
192  *	with the -l flag. No warning or error if this does not succeed (we will
204 	 * we do not try to link to directories in case we are running as root  in cross_lnk()
214  *	In copy mode if we are not trying to make hard links between the src
215  *	and destinations, make sure we are not going to overwrite ourselves by
216  *	accident. This slows things down a little, but we have to protect all
250  *	try to make a hard link between two files. if ign set, we do not
253  *	0 if successful (or we are done with this file but no error, such as
255  *	1 when ign was set to indicates we could not make the link but we
386 			 * we should never get here  in node_creat()
394 		 * if we were able to create the node break out of the loop,  in node_creat()
402 		 * we failed to make the node  in node_creat()
418 	 * we were able to create the node. set uid/gid, modes and times  in node_creat()
427 	 * if not preserving mode or we cannot set uid/gid, then PROHIBIT any  in node_creat()
439 		 * to allow extract to continue, we may have to also set owner  in node_creat()
452 				 * We have to add rights to the dir, so we make  in node_creat()
464 			 * we have to force the mode to what was set here,  in node_creat()
465 			 * since we changed it from the default as created.  in node_creat()
479  *	Remove node from file system with the specified name. We pass the type
480  *	of the node that is going to replace it. When we try to create a
481  *	directory and find that it already exists, we allow processing to
485  *	-1 we were unable to remove the node, or we should not remove it (-k)
486  *	1 we found a directory and we were going to create a directory.
495 	 * the file does not exist, or -k we are done  in unlnk_exist()
504 		 * try to remove a directory, if it fails and we were going to  in unlnk_exist()
528  *	We were trying to create some kind of node in the file system and it
530  *	writeable. When we have to create a directory that is missing along the
531  *	path somewhere, the directory we create will be set to the same
560 		 * skip creating a leaf dir (with an ending '/') as we only want  in chk_path()
568 		 * if it exists we assume it is a directory, it is not within  in chk_path()
582 		 * the path fails at this point, see if we can create the  in chk_path()
592 		 * we were able to create the directory. We will tell the  in chk_path()
593 		 * caller that we found something to fix, and it is ok to try  in chk_path()
602 		 * causes this newly created directory to be unusable. We fix  in chk_path()
620  *	non-zero we force these times to be set even if the user did not
624  *	other ones are left alone. We do not assume the un-documented feature
639 		 * if we are not forcing, only set those times the user wants  in set_ftime()
640 		 * set. We get the current values of the times if we need them.  in set_ftime()
708  *	we only know that a file block of all zero's can be a hole).
710  *	with holes. However, on extraction (or during copy, -rw) we have to
716  *	While the input is all zero keep doing an lseek. Keep track of when we
717  *	pass over file block boundaries. Only write when we hit a non zero
718  *	input. once we have written a file block, we continue to write it to
719  *	the end (we stop looking at the input). When we reach the start of the
727  *	file space). (Except on paging files for diskless clients. But since we
728  *	cannot determine one of those file from here, we ignore them). If this
734  *	the end. In this case we drop a single 0 at the end to force the
738  *	isempt: have we written to the file block yet (is it empty)
756 	 * while we have data to process  in file_write()
761 			 * We are now at the start of file system block again  in file_write()
762 			 * (or what we think one is...). start looking for  in file_write()
778 			 * have not written to this block yet, so we keep  in file_write()
823  *	let us create a hole at the end. To get the last block with zeros, we
833 	 * silly test, but make sure we are only called when the last block is  in file_flush()
854  *	close a file we have beed reading (to copy or archive). If we have to
882  *	that have this, end up reading the file twice (we have to write the
911 	 * read all the bytes we think that there are in the file. If the user  in set_crc()
923 	 * safety check. we want to avoid archiving files that are active as  in set_crc()