fbt/sbase
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
9304b84c92
sbase/ln.c

90 lines
1.8 KiB
C
Raw Normal View History

add ln, util.a
2011-05-24 12:00:30 +00:00
/* See LICENSE file for copyright and license details. */
Clean up #includes
2015-02-14 20:02:41 +00:00
#include <sys/stat.h>
Audit ln(1) 1) Clarify behaviour when the f-flag is given and a target is in its own way. 2) Fix usage()-style. 3) Group local variable declarations. 4) reorder args 5) argc style, other boolean style changes 6) improve error messages 7) set argv[argc - 1] to NULL to allow argv-centric loop later 8) BUGFIX: POSIX specifies that when with the f-flag there's a situation where a file stands in its own way for linking it should be ignored. 9) Add weprintf() where possible, so we don't pussy out when there's a small issue. This is sbase ffs!
2015-03-05 20:14:43 +00:00
#include <errno.h>
ln: Add support for target directories Also, now that we are using {sym,}linkat, implement the trivial -L and -P options.
2014-11-23 20:25:39 +00:00
#include <fcntl.h>
Fix a completely broken ln(1)
2014-10-17 15:03:41 +00:00
#include <libgen.h>
#include <unistd.h>
Fix coding style It was about damn time. Consistency is very important in such a big codebase.
2014-11-13 17:29:30 +00:00
add ln, util.a
2011-05-24 12:00:30 +00:00
#include "util.h"
Eliminating the getopt disgrace.
2013-06-14 18:20:47 +00:00
static void
usage(void)
{
ln: usage, just use %s
2015-01-31 14:23:59 +00:00
eprintf("usage: %s [-f] [-L | -P | -s] target [name]\n"
Audit ln(1) 1) Clarify behaviour when the f-flag is given and a target is in its own way. 2) Fix usage()-style. 3) Group local variable declarations. 4) reorder args 5) argc style, other boolean style changes 6) improve error messages 7) set argv[argc - 1] to NULL to allow argv-centric loop later 8) BUGFIX: POSIX specifies that when with the f-flag there's a situation where a file stands in its own way for linking it should be ignored. 9) Add weprintf() where possible, so we don't pussy out when there's a small issue. This is sbase ffs!
2015-03-05 20:14:43 +00:00
" %s [-f] [-L | -P | -s] target ... dir\n", argv0, argv0);
Eliminating the getopt disgrace.
2013-06-14 18:20:47 +00:00
}
add ln, util.a
2011-05-24 12:00:30 +00:00
int
main(int argc, char *argv[])
{
ln: allow with one argument Signed-off-by: Hiltjo Posthuma <hiltjo@codemadness.org>
2014-07-10 21:00:02 +00:00
char *fname, *to;
ln: exit non-zero when errors accured
2015-05-08 08:16:58 +00:00
int sflag = 0, fflag = 0, hasto = 0, dirfd = AT_FDCWD, ret = 0,
flags = AT_SYMLINK_FOLLOW;
Audit ln(1) 1) Clarify behaviour when the f-flag is given and a target is in its own way. 2) Fix usage()-style. 3) Group local variable declarations. 4) reorder args 5) argc style, other boolean style changes 6) improve error messages 7) set argv[argc - 1] to NULL to allow argv-centric loop later 8) BUGFIX: POSIX specifies that when with the f-flag there's a situation where a file stands in its own way for linking it should be ignored. 9) Add weprintf() where possible, so we don't pussy out when there's a small issue. This is sbase ffs!
2015-03-05 20:14:43 +00:00
struct stat st, tost;
Simplify ln(1)
2014-02-17 11:41:37 +00:00
Eliminating the getopt disgrace.
2013-06-14 18:20:47 +00:00
ARGBEGIN {
case 'f':
Un-boolify sbase It actually makes the binaries smaller, the code easier to read (gems like "val == true", "val == false" are gone) and actually predictable in the sense of that we actually know what we're working with (one bitwise operator was quite adventurous and should now be fixed). This is also more consistent with the other suckless projects around which don't use boolean types.
2014-11-13 20:24:47 +00:00
fflag = 1;
Eliminating the getopt disgrace.
2013-06-14 18:20:47 +00:00
break;
ln: Add support for target directories Also, now that we are using {sym,}linkat, implement the trivial -L and -P options.
2014-11-23 20:25:39 +00:00
case 'L':
flags |= AT_SYMLINK_FOLLOW;
break;
case 'P':
flags &= ~AT_SYMLINK_FOLLOW;
break;
Audit ln(1) 1) Clarify behaviour when the f-flag is given and a target is in its own way. 2) Fix usage()-style. 3) Group local variable declarations. 4) reorder args 5) argc style, other boolean style changes 6) improve error messages 7) set argv[argc - 1] to NULL to allow argv-centric loop later 8) BUGFIX: POSIX specifies that when with the f-flag there's a situation where a file stands in its own way for linking it should be ignored. 9) Add weprintf() where possible, so we don't pussy out when there's a small issue. This is sbase ffs!
2015-03-05 20:14:43 +00:00
case 's':
sflag = 1;
break;
Eliminating the getopt disgrace.
2013-06-14 18:20:47 +00:00
default:
usage();
} ARGEND;
Audit ln(1) 1) Clarify behaviour when the f-flag is given and a target is in its own way. 2) Fix usage()-style. 3) Group local variable declarations. 4) reorder args 5) argc style, other boolean style changes 6) improve error messages 7) set argv[argc - 1] to NULL to allow argv-centric loop later 8) BUGFIX: POSIX specifies that when with the f-flag there's a situation where a file stands in its own way for linking it should be ignored. 9) Add weprintf() where possible, so we don't pussy out when there's a small issue. This is sbase ffs!
2015-03-05 20:14:43 +00:00
if (!argc)
Fix a completely broken ln(1)
2014-10-17 15:03:41 +00:00
usage();
ln: Add support for target directories Also, now that we are using {sym,}linkat, implement the trivial -L and -P options.
2014-11-23 20:25:39 +00:00
fname = sflag ? "symlink" : "link";
ln: allow with one argument Signed-off-by: Hiltjo Posthuma <hiltjo@codemadness.org>
2014-07-10 21:00:02 +00:00
ln: Add support for target directories Also, now that we are using {sym,}linkat, implement the trivial -L and -P options.
2014-11-23 20:25:39 +00:00
if (argc >= 2) {
Audit ln(1) 1) Clarify behaviour when the f-flag is given and a target is in its own way. 2) Fix usage()-style. 3) Group local variable declarations. 4) reorder args 5) argc style, other boolean style changes 6) improve error messages 7) set argv[argc - 1] to NULL to allow argv-centric loop later 8) BUGFIX: POSIX specifies that when with the f-flag there's a situation where a file stands in its own way for linking it should be ignored. 9) Add weprintf() where possible, so we don't pussy out when there's a small issue. This is sbase ffs!
2015-03-05 20:14:43 +00:00
if (!stat(argv[argc - 1], &st) && S_ISDIR(st.st_mode)) {
ln: Add support for target directories Also, now that we are using {sym,}linkat, implement the trivial -L and -P options.
2014-11-23 20:25:39 +00:00
if ((dirfd = open(argv[argc - 1], O_RDONLY)) < 0)
Audit ln(1) 1) Clarify behaviour when the f-flag is given and a target is in its own way. 2) Fix usage()-style. 3) Group local variable declarations. 4) reorder args 5) argc style, other boolean style changes 6) improve error messages 7) set argv[argc - 1] to NULL to allow argv-centric loop later 8) BUGFIX: POSIX specifies that when with the f-flag there's a situation where a file stands in its own way for linking it should be ignored. 9) Add weprintf() where possible, so we don't pussy out when there's a small issue. This is sbase ffs!
2015-03-05 20:14:43 +00:00
eprintf("open %s:", argv[argc - 1]);
ln: Add support for target directories Also, now that we are using {sym,}linkat, implement the trivial -L and -P options.
2014-11-23 20:25:39 +00:00
} else if (argc == 2) {
Audit ln(1) 1) Clarify behaviour when the f-flag is given and a target is in its own way. 2) Fix usage()-style. 3) Group local variable declarations. 4) reorder args 5) argc style, other boolean style changes 6) improve error messages 7) set argv[argc - 1] to NULL to allow argv-centric loop later 8) BUGFIX: POSIX specifies that when with the f-flag there's a situation where a file stands in its own way for linking it should be ignored. 9) Add weprintf() where possible, so we don't pussy out when there's a small issue. This is sbase ffs!
2015-03-05 20:14:43 +00:00
to = argv[argc - 1];
ln: Add support for target directories Also, now that we are using {sym,}linkat, implement the trivial -L and -P options.
2014-11-23 20:25:39 +00:00
hasto = 1;
} else {
Audit ln(1) 1) Clarify behaviour when the f-flag is given and a target is in its own way. 2) Fix usage()-style. 3) Group local variable declarations. 4) reorder args 5) argc style, other boolean style changes 6) improve error messages 7) set argv[argc - 1] to NULL to allow argv-centric loop later 8) BUGFIX: POSIX specifies that when with the f-flag there's a situation where a file stands in its own way for linking it should be ignored. 9) Add weprintf() where possible, so we don't pussy out when there's a small issue. This is sbase ffs!
2015-03-05 20:14:43 +00:00
eprintf("%s: not a directory\n", argv[argc - 1]);
ln: Add support for target directories Also, now that we are using {sym,}linkat, implement the trivial -L and -P options.
2014-11-23 20:25:39 +00:00
}
Audit ln(1) 1) Clarify behaviour when the f-flag is given and a target is in its own way. 2) Fix usage()-style. 3) Group local variable declarations. 4) reorder args 5) argc style, other boolean style changes 6) improve error messages 7) set argv[argc - 1] to NULL to allow argv-centric loop later 8) BUGFIX: POSIX specifies that when with the f-flag there's a situation where a file stands in its own way for linking it should be ignored. 9) Add weprintf() where possible, so we don't pussy out when there's a small issue. This is sbase ffs!
2015-03-05 20:14:43 +00:00
argv[argc - 1] = NULL;
ln: Add support for target directories Also, now that we are using {sym,}linkat, implement the trivial -L and -P options.
2014-11-23 20:25:39 +00:00
argc--;
}
Simplify ln(1)
2014-02-17 11:41:37 +00:00
Audit ln(1) 1) Clarify behaviour when the f-flag is given and a target is in its own way. 2) Fix usage()-style. 3) Group local variable declarations. 4) reorder args 5) argc style, other boolean style changes 6) improve error messages 7) set argv[argc - 1] to NULL to allow argv-centric loop later 8) BUGFIX: POSIX specifies that when with the f-flag there's a situation where a file stands in its own way for linking it should be ignored. 9) Add weprintf() where possible, so we don't pussy out when there's a small issue. This is sbase ffs!
2015-03-05 20:14:43 +00:00
for (; *argv; argc--, argv++) {
ln: Add support for target directories Also, now that we are using {sym,}linkat, implement the trivial -L and -P options.
2014-11-23 20:25:39 +00:00
if (!hasto)
Audit ln(1) 1) Clarify behaviour when the f-flag is given and a target is in its own way. 2) Fix usage()-style. 3) Group local variable declarations. 4) reorder args 5) argc style, other boolean style changes 6) improve error messages 7) set argv[argc - 1] to NULL to allow argv-centric loop later 8) BUGFIX: POSIX specifies that when with the f-flag there's a situation where a file stands in its own way for linking it should be ignored. 9) Add weprintf() where possible, so we don't pussy out when there's a small issue. This is sbase ffs!
2015-03-05 20:14:43 +00:00
to = basename(*argv);
ln: only check existence of src/to for hardlinks This allows for creating dangling symlinks with force applied: # Before: $ ln -sf non-existant target ln: stat non-existent: No such file or directory $ ls -l target ls: lstat target: No such file or directory # After: $ ln -sf non-existant target $ ls -l target lrwxrwxrwx 1 eu users 12 May 08 07:50 target -> non-existent This also allows creating relative non-dangling symlinks with force applied: touch existant; mkdir dir # Before $ ln -sf ../existant dir ln: stat ../existant: No such file or directory $ ls -l dir # After $ ln -sf ../existant dir $ ls -l dir lrwxrwxrwx 1 eu users 11 May 08 07:53 existant -> ../existant The check for whether each src and to pairs are on the same device with the same inode are only needed for hardlinks so that a forcefull link does not remove the underlying file: touch f; mkdir dir # Before: $ ln -f f f dir ln: f and f are the same file $ ls -i f dir/f 3670611 dir/f 3670611 f # After: $ ln -f f f dir ln: f and f are the same file $ ls -i f dir/f 4332236 dir/f 4332236 f
2015-05-08 08:16:57 +00:00
if (!sflag) {
Audit ln(1) 1) Clarify behaviour when the f-flag is given and a target is in its own way. 2) Fix usage()-style. 3) Group local variable declarations. 4) reorder args 5) argc style, other boolean style changes 6) improve error messages 7) set argv[argc - 1] to NULL to allow argv-centric loop later 8) BUGFIX: POSIX specifies that when with the f-flag there's a situation where a file stands in its own way for linking it should be ignored. 9) Add weprintf() where possible, so we don't pussy out when there's a small issue. This is sbase ffs!
2015-03-05 20:14:43 +00:00
if (stat(*argv, &st) < 0) {
weprintf("stat %s:", *argv);
ln: exit non-zero when errors accured
2015-05-08 08:16:58 +00:00
ret = 1;
Audit ln(1) 1) Clarify behaviour when the f-flag is given and a target is in its own way. 2) Fix usage()-style. 3) Group local variable declarations. 4) reorder args 5) argc style, other boolean style changes 6) improve error messages 7) set argv[argc - 1] to NULL to allow argv-centric loop later 8) BUGFIX: POSIX specifies that when with the f-flag there's a situation where a file stands in its own way for linking it should be ignored. 9) Add weprintf() where possible, so we don't pussy out when there's a small issue. This is sbase ffs!
2015-03-05 20:14:43 +00:00
continue;
} else if (fstatat(dirfd, to, &tost, AT_SYMLINK_NOFOLLOW) < 0) {
if (errno != ENOENT)
eprintf("stat %s:", to);
ln: only check existence of src/to for hardlinks This allows for creating dangling symlinks with force applied: # Before: $ ln -sf non-existant target ln: stat non-existent: No such file or directory $ ls -l target ls: lstat target: No such file or directory # After: $ ln -sf non-existant target $ ls -l target lrwxrwxrwx 1 eu users 12 May 08 07:50 target -> non-existent This also allows creating relative non-dangling symlinks with force applied: touch existant; mkdir dir # Before $ ln -sf ../existant dir ln: stat ../existant: No such file or directory $ ls -l dir # After $ ln -sf ../existant dir $ ls -l dir lrwxrwxrwx 1 eu users 11 May 08 07:53 existant -> ../existant The check for whether each src and to pairs are on the same device with the same inode are only needed for hardlinks so that a forcefull link does not remove the underlying file: touch f; mkdir dir # Before: $ ln -f f f dir ln: f and f are the same file $ ls -i f dir/f 3670611 dir/f 3670611 f # After: $ ln -f f f dir ln: f and f are the same file $ ls -i f dir/f 4332236 dir/f 4332236 f
2015-05-08 08:16:57 +00:00
} else if (st.st_dev == tost.st_dev && st.st_ino == tost.st_ino) {
weprintf("%s and %s are the same file\n", *argv, *argv);
ln: exit non-zero when errors accured
2015-05-08 08:16:58 +00:00
ret = 1;
ln: only check existence of src/to for hardlinks This allows for creating dangling symlinks with force applied: # Before: $ ln -sf non-existant target ln: stat non-existent: No such file or directory $ ls -l target ls: lstat target: No such file or directory # After: $ ln -sf non-existant target $ ls -l target lrwxrwxrwx 1 eu users 12 May 08 07:50 target -> non-existent This also allows creating relative non-dangling symlinks with force applied: touch existant; mkdir dir # Before $ ln -sf ../existant dir ln: stat ../existant: No such file or directory $ ls -l dir # After $ ln -sf ../existant dir $ ls -l dir lrwxrwxrwx 1 eu users 11 May 08 07:53 existant -> ../existant The check for whether each src and to pairs are on the same device with the same inode are only needed for hardlinks so that a forcefull link does not remove the underlying file: touch f; mkdir dir # Before: $ ln -f f f dir ln: f and f are the same file $ ls -i f dir/f 3670611 dir/f 3670611 f # After: $ ln -f f f dir ln: f and f are the same file $ ls -i f dir/f 4332236 dir/f 4332236 f
2015-05-08 08:16:57 +00:00
continue;
Audit ln(1) 1) Clarify behaviour when the f-flag is given and a target is in its own way. 2) Fix usage()-style. 3) Group local variable declarations. 4) reorder args 5) argc style, other boolean style changes 6) improve error messages 7) set argv[argc - 1] to NULL to allow argv-centric loop later 8) BUGFIX: POSIX specifies that when with the f-flag there's a situation where a file stands in its own way for linking it should be ignored. 9) Add weprintf() where possible, so we don't pussy out when there's a small issue. This is sbase ffs!
2015-03-05 20:14:43 +00:00
}
}
ln: only check existence of src/to for hardlinks This allows for creating dangling symlinks with force applied: # Before: $ ln -sf non-existant target ln: stat non-existent: No such file or directory $ ls -l target ls: lstat target: No such file or directory # After: $ ln -sf non-existant target $ ls -l target lrwxrwxrwx 1 eu users 12 May 08 07:50 target -> non-existent This also allows creating relative non-dangling symlinks with force applied: touch existant; mkdir dir # Before $ ln -sf ../existant dir ln: stat ../existant: No such file or directory $ ls -l dir # After $ ln -sf ../existant dir $ ls -l dir lrwxrwxrwx 1 eu users 11 May 08 07:53 existant -> ../existant The check for whether each src and to pairs are on the same device with the same inode are only needed for hardlinks so that a forcefull link does not remove the underlying file: touch f; mkdir dir # Before: $ ln -f f f dir ln: f and f are the same file $ ls -i f dir/f 3670611 dir/f 3670611 f # After: $ ln -f f f dir ln: f and f are the same file $ ls -i f dir/f 4332236 dir/f 4332236 f
2015-05-08 08:16:57 +00:00
if (fflag)
unlinkat(dirfd, to, 0);
Audit ln(1) 1) Clarify behaviour when the f-flag is given and a target is in its own way. 2) Fix usage()-style. 3) Group local variable declarations. 4) reorder args 5) argc style, other boolean style changes 6) improve error messages 7) set argv[argc - 1] to NULL to allow argv-centric loop later 8) BUGFIX: POSIX specifies that when with the f-flag there's a situation where a file stands in its own way for linking it should be ignored. 9) Add weprintf() where possible, so we don't pussy out when there's a small issue. This is sbase ffs!
2015-03-05 20:14:43 +00:00
if ((!sflag ? linkat(AT_FDCWD, *argv, dirfd, to, flags)
: symlinkat(*argv, dirfd, to)) < 0) {
weprintf("%s %s <- %s:", fname, *argv, to);
ln: exit non-zero when errors accured
2015-05-08 08:16:58 +00:00
ret = 1;
ln: Add support for target directories Also, now that we are using {sym,}linkat, implement the trivial -L and -P options.
2014-11-23 20:25:39 +00:00
}
}
Eliminating the getopt disgrace.
2013-06-14 18:20:47 +00:00
ln: exit non-zero when errors accured
2015-05-08 08:16:58 +00:00
return ret;
add ln, util.a
2011-05-24 12:00:30 +00:00
}
Reference in New Issue Copy Permalink