Home Man
Today's Posts

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:
Select Section of Man Page:
Select Man Page Repository:

Linux 2.6 - man page for unlink (linux section 3posix)

UNLINK(P)			    POSIX Programmer's Manual				UNLINK(P)

       unlink - remove a directory entry

       #include <unistd.h>

       int unlink(const char *path);

       The  unlink()  function	shall  remove  a  link	to a file. If path names a symbolic link,
       unlink() shall remove the symbolic link named by path and shall not  affect  any  file  or
       directory  named  by  the contents of the symbolic link.  Otherwise, unlink() shall remove
       the link named by the pathname pointed to by path and shall decrement the  link	count  of
       the file referenced by the link.

       When  the file's link count becomes 0 and no process has the file open, the space occupied
       by the file shall be freed and the file shall no longer be accessible. If one or more pro-
       cesses  have the file open when the last link is removed, the link shall be removed before
       unlink() returns, but the removal of the file contents shall be postponed until all refer-
       ences to the file are closed.

       The path argument shall not name a directory unless the process has appropriate privileges
       and the implementation supports using unlink() on directories.

       Upon successful completion, unlink() shall mark	for  update  the  st_ctime  and  st_mtime
       fields  of  the	parent	directory.  Also, if the file's link count is not 0, the st_ctime
       field of the file shall be marked for update.

       Upon successful completion, 0 shall be returned. Otherwise, -1 shall be returned and errno
       set to indicate the error. If -1 is returned, the named file shall not be changed.

       The unlink() function shall fail and shall not unlink the file if:

       EACCES Search permission is denied for a component of the path prefix, or write permission
	      is denied on the directory containing the directory entry to be removed.

       EBUSY  The file named by the path argument cannot be unlinked because it is being used  by
	      the system or another process and the implementation considers this an error.

       ELOOP  A loop exists in symbolic links encountered during resolution of the path argument.

	      The  length  of  the  path  argument  exceeds {PATH_MAX} or a pathname component is
	      longer than {NAME_MAX}.

       ENOENT A component of path does not name an existing file or path is an empty string.

	      A component of the path prefix is not a directory.

       EPERM  The file named by path is a directory, and either the calling process does not have
	      appropriate  privileges, or the implementation prohibits using unlink() on directo-

       EPERM or EACCES

	      The S_ISVTX flag is set on the directory containing the file  referred  to  by  the
	      path argument and the caller is not the file owner, nor is the caller the directory
	      owner, nor does the caller have appropriate privileges.

       EROFS  The directory entry to be unlinked is part of a read-only file system.

       The unlink() function may fail and not unlink the file if:

       EBUSY  The file named by path is a named STREAM.

       ELOOP  More than {SYMLOOP_MAX} symbolic links were encountered during  resolution  of  the
	      path argument.

	      As a result of encountering a symbolic link in resolution of the path argument, the
	      length of the substituted pathname string exceeded {PATH_MAX}.

	      The entry to be unlinked is the last directory entry to a  pure  procedure  (shared
	      text) file that is being executed.

       The following sections are informative.

   Removing a Link to a File
       The  following example shows how to remove a link to a file named /home/cnd/mod1 by remov-
       ing the entry named /modules/pass1.

	      #include <unistd.h>

	      char *path = "/modules/pass1";
	      int   status;
	      status = unlink(path);

   Checking for an Error
       The following example fragment creates a temporary  password  lock  file  named	LOCKFILE,
       which  is  defined  as /etc/ptmp, and gets a file descriptor for it. If the file cannot be
       opened for writing, unlink() is used to remove the link between the  file  descriptor  and

	      #include <sys/types.h>
	      #include <stdio.h>
	      #include <fcntl.h>
	      #include <errno.h>
	      #include <unistd.h>
	      #include <sys/stat.h>

	      #define LOCKFILE "/etc/ptmp"

	      int pfd;	/* Integer for file descriptor returned by open call. */
	      FILE *fpfd;  /* File pointer for use in putpwent(). */
	      /* Open password Lock file. If it exists, this is an error. */
	      if ((pfd = open(LOCKFILE, O_WRONLY| O_CREAT | O_EXCL, S_IRUSR
		  | S_IWUSR | S_IRGRP | S_IROTH)) == -1)  {
		  fprintf(stderr, "Cannot open /etc/ptmp. Try again later.\n");

	      /* Lock file created; proceed with fdopen of lock file so that
		 putpwent() can be used.
	      if ((fpfd = fdopen(pfd, "w")) == NULL) {

   Replacing Files
       The  following  example fragment uses unlink() to discard links to files, so that they can
       be replaced with new versions of the files. The first call removes the link to LOCKFILE if
       an  error occurs. Successive calls remove the links to SAVEFILE and PASSWDFILE so that new
       links can be created, then removes the link to LOCKFILE when it is no longer needed.

	      #include <sys/types.h>
	      #include <stdio.h>
	      #include <fcntl.h>
	      #include <errno.h>
	      #include <unistd.h>
	      #include <sys/stat.h>

	      #define LOCKFILE "/etc/ptmp"
	      #define PASSWDFILE "/etc/passwd"
	      #define SAVEFILE "/etc/opasswd"
	      /* If no change was made, assume error and leave passwd unchanged. */
	      if (!valid_change) {
		  fprintf(stderr, "Could not change password for user %s\n", user);

	      /* Change permissions on new password file. */
	      chmod(LOCKFILE, S_IRUSR | S_IRGRP | S_IROTH);

	      /* Remove saved password file. */

	      /* Save current password file. */

	      /* Remove current password file. */

	      /* Save new password file as current password file. */

	      /* Remove lock file. */


       Applications should use rmdir() to remove a directory.

       Unlinking a directory is restricted to the superuser in	many  historical  implementations
       for reasons given in link() (see also rename()).

       The  meaning  of  [EBUSY]  in historical implementations is "mount point busy". Since this
       volume of IEEE Std 1003.1-2001 does not cover the system administration concepts of mount-
       ing  and  unmounting,  the  description of the error was changed to "resource busy". (This
       meaning is used by some device drivers when a second process tries to  open  an	exclusive
       use  device.)  The wording is also intended to allow implementations to refuse to remove a
       directory if it is the root or current working directory of any process.


       close()	,  link()  ,  remove()	 ,   rmdir()   ,   the	 Base	Definitions   volume   of
       IEEE Std 1003.1-2001, <unistd.h>

       Portions  of  this  text  are  reprinted  and  reproduced in electronic form from IEEE Std
       1003.1, 2003 Edition, Standard for Information Technology  --  Portable	Operating  System
       Interface  (POSIX), The Open Group Base Specifications Issue 6, Copyright (C) 2001-2003 by
       the Institute of Electrical and Electronics Engineers, Inc and  The  Open  Group.  In  the
       event  of  any  discrepancy  between this version and the original IEEE and The Open Group
       Standard, the original IEEE and The Open Group Standard is the referee document. The orig-
       inal Standard can be obtained online at http://www.opengroup.org/unix/online.html .

IEEE/The Open Group			       2003					UNLINK(P)

All times are GMT -4. The time now is 12:09 AM.

Unix & Linux Forums Content Copyrightę1993-2018. All Rights Reserved.
Show Password