func main() {
atime = time.Now()
mtime = time.Now()
goopt.Author = "William Pearson"
goopt.Version = "Touch"
goopt.Summary = "Change access or modification time of each FILE"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... FILE...\n", os.Args[0]) +
goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
access := goopt.Flag([]string{"-a"}, nil, "Only change access time", "")
modify := goopt.Flag([]string{"-m"}, nil, "Only change modification time", "")
create := goopt.Flag([]string{"-c"}, nil, "Only change modification time", "")
Nodereference = goopt.Flag([]string{"-h", "--no-dereference"}, []string{"--derference"}, "Affect symbolic links directly instead of dereferencing them", "Dereference symbolic links before operating on them (This is default)")
goopt.OptArg([]string{"-r", "--reference"}, "RFILE", "Use RFILE's owner and group", fromReference)
goopt.OptArg([]string{"-t"}, "STAMP", "Use [[CC]YY]MMDDhhmm[.ss] instead of now. Note hh is interpreted as from 00 to 23", fromStamp)
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
coreutils.Noderef = *Nodereference
if len(goopt.Args) == 0 {
coreutils.PrintUsage()
}
if !*access && !*modify {
*access, *modify = true, true
}
for i := range goopt.Args {
if !*access {
atime, _ = GetAtimeMtime(goopt.Args[i], *Nodereference)
}
if !*modify {
_, mtime = GetAtimeMtime(goopt.Args[i], *Nodereference)
}
if err := os.Chtimes(goopt.Args[i], atime, mtime); err != nil {
if os.IsNotExist(err) {
var err error
if !*create {
f, err := os.Create(goopt.Args[i])
if err == nil {
f.Close()
}
}
if err == nil {
continue
}
}
fmt.Fprintf(os.Stderr, "Error touching file '%s': %v\n", goopt.Args[i], err)
}
}
return
}
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Rmdir"
goopt.Summary = "Remove each DIRECTORY if it is empty"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... DIRECTORY...\n", os.Args[0]) + goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
ignorefail := goopt.Flag([]string{"--ignore-fail-on-non-empty"}, nil,
"Ignore each failure that is from a directory not being empty", "")
parents := goopt.Flag([]string{"-p", "--parents"}, nil, "Remove DIRECTORY and ancestors if ancestors become empty", "")
verbose := goopt.Flag([]string{"-v", "--verbose"}, nil, "Output each directory as it is processed", "")
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if len(goopt.Args) == 0 {
coreutils.PrintUsage()
}
for i := range goopt.Args {
filelisting, err := ioutil.ReadDir(goopt.Args[i])
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to remove %s: %v\n", os.Args[i+1], err)
defer os.Exit(1)
continue
}
if !*ignorefail && len(filelisting) > 0 {
fmt.Fprintf(os.Stderr, "Failed to remove '%s' directory is non-empty\n", goopt.Args[i])
defer os.Exit(1)
continue
}
if *verbose {
fmt.Printf("Removing directory %s\n", goopt.Args[i])
}
err = os.Remove(goopt.Args[i])
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to remove %s: %v\n", goopt.Args[i], err)
defer os.Exit(1)
continue
}
if !*parents {
continue
}
dir := goopt.Args[i]
if dir[len(dir)-1] == '/' {
dir = filepath.Dir(dir)
}
if removeEmptyParents(dir, *verbose, *ignorefail) {
defer os.Exit(1)
}
}
return
}
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Chmod"
goopt.Summary = "Change file mode of each FILE to MODE\nWith reference, change file mode of each FILE to that of RFILE"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... [MODE] FILE...\n or:\t%s [OPTION]... --reference=RFILE FILE...\n", os.Args[0], os.Args[0]) +
goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
silent := goopt.Flag([]string{"-f", "--silent", "--quiet"}, nil, "Suppress most error messages", "")
/*changes := goopt.Flag([]string{"-c", "--changes"}, nil, "Like verbose but only report changes", "")
verbose := goopt.Flag([]string{"-v", "--verbose"}, nil, "Output each file as it is processed", "")*/
nodereference := goopt.Flag([]string{"-h", "--no-dereference"}, []string{"--derference"}, "Affect symbolic links directly instead of dereferencing them", "Dereference symbolic links before operating on them (This is default)")
preserveroot := goopt.Flag([]string{"--preserve-root"}, []string{"--no-preserve-root"}, "Don't recurse on '/'", "Treat '/' normally (This is default)")
goopt.OptArg([]string{"--reference"}, "RFILE", "Use RFILE's owner and group", fromReference)
recurse := goopt.Flag([]string{"-R", "--recursive"}, nil, "Operate recursively on files and directories", "")
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if len(goopt.Args) == 0 {
coreutils.PrintUsage()
}
coreutils.Noderef = *nodereference
coreutils.Preserveroot = *preserveroot
if !usingreference {
coreutils.ParseMode(goopt.Args[0])
}
var filestomod []string
for i := range goopt.Args[1:] {
filestomod = append(filestomod, goopt.Args[i+1])
if *recurse && (!*preserveroot || goopt.Args[i+1] != "/") {
if coreutils.Recurse(&filestomod) {
defer os.Exit(1)
}
}
}
for i := range filestomod {
err := os.Chmod(filestomod[i], coreutils.Mode)
if err != nil && !*silent {
fmt.Fprintf(os.Stderr, "Error changing mode for file '%s': %v\n", filestomod[i], err)
defer os.Exit(1)
continue
}
}
return
}
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Sync"
goopt.Summary = "Flush filesystem buffers"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s OPTION\n", os.Args[0]) + goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless an option is passed to it."
}
goopt.NoArg([]string{"-v", "--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if len(goopt.Args) != 0 {
coreutils.PrintUsage()
}
Sync()
return
}
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Unlink"
goopt.Summary = "Uses unlink to remove FILE"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s FILE\n or:\t%s OPTION\n", os.Args[0], os.Args[0]) + goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless an option is passed to it."
}
goopt.NoArg([]string{"-v", "--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if len(goopt.Args) != 1 {
coreutils.PrintUsage()
}
file := goopt.Args[0]
if err := syscall.Unlink(file); err != nil {
fmt.Fprintf(os.Stderr, "Encountered an error during unlinking: %v\n", err)
os.Exit(1)
}
return
}
func main() {
coreutils.Mode = 1<<31 | coreutils.Mode
goopt.Author = "William Pearson"
goopt.Version = "Mkdir"
goopt.Summary = "Create each DIRECTORY, if it does not already exist."
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... DIRECTORY...\n", os.Args[0]) + goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
goopt.OptArg([]string{"-m", "--mode"}, "MODE", "Set file mode permissions", coreutils.ParseMode)
parents := goopt.Flag([]string{"-p", "--parents"}, nil, "Make parent directories as needed, no error if existing", "")
verbose := goopt.Flag([]string{"-v", "--verbose"}, nil, "Output each directory as it is processed", "")
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if len(goopt.Args) == 0 {
coreutils.PrintUsage()
}
for i := range goopt.Args {
if *parents {
if createParents(goopt.Args[i], *verbose) {
defer os.Exit(1)
}
continue
}
if *verbose {
fmt.Printf("Creating directory %s\n", goopt.Args[i])
}
err := os.Mkdir(goopt.Args[i], coreutils.Mode)
if err != nil {
fmt.Fprintf(os.Stderr, "Error creating direction %s: %v\n", goopt.Args[i], err)
defer os.Exit(1)
}
}
return
}
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Rm"
goopt.Summary = "Remove each FILE"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... FILE...\n", os.Args[0]) + goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
force = goopt.Flag([]string{"-f", "--force"}, nil, "Ignore nonexistent files, don't prompt user", "")
prompteach = goopt.Flag([]string{"-i"}, nil, "Prompt before each removal", "")
promptonce = goopt.Flag([]string{"-I"}, nil, "Prompt before removing multiple files at once", "")
goopt.OptArg([]string{"--interactive"}, "WHEN", "Prompt according to WHEN", setPrompt)
/*onefs := goopt.Flag([]string{"--one-file-system"}, nil, "When -r is specified, skip directories on different filesystems", "")*/
nopreserveroot := goopt.Flag([]string{"--no-preserve-root"}, []string{"--preserve-root"}, "Do not treat '/' specially", "Do not remove '/' (This is default)")
recurse := goopt.Flag([]string{"-r", "-R", "--recursive"}, nil, "Recursively remove directories and their contents", "")
emptydir := goopt.Flag([]string{"-d", "--dir"}, nil, "Remove empty directories", "")
verbose := goopt.Flag([]string{"-v", "--verbose"}, nil, "Output each file as it is processed", "")
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
promptno := true
var filenames []string
if len(goopt.Args) == 0 {
coreutils.PrintUsage()
}
coreutils.Preserveroot = !*nopreserveroot
coreutils.Silent = *force
coreutils.Prompt = *prompteach || *promptonce
coreutils.PromptFunc = func(filename string, remove bool) bool {
var prompt string
if remove {
prompt = "Remove " + filename + "?"
} else {
prompt = "Recurse into " + filename + "?"
}
var response string
trueresponse := "yes"
falseresponse := "no"
for {
fmt.Print(prompt)
fmt.Scanln(&response)
response = strings.ToLower(response)
if strings.Contains(trueresponse, response) {
return true
} else if strings.Contains(falseresponse, response) || response == "" {
return false
}
}
}
for i := range goopt.Args {
_, err := os.Lstat(goopt.Args[i])
if *force && os.IsNotExist(err) {
continue
}
if err != nil {
fmt.Fprintf(os.Stderr, "Error getting file info for '%s': %v\n", goopt.Args[i], err)
defer os.Exit(1)
continue
}
filenames = append(filenames, goopt.Args[i])
if *recurse {
if coreutils.Recurse(&filenames) {
defer os.Exit(1)
}
}
}
sort.Strings(filenames)
l := len(filenames) - 1
for i := range filenames {
fileinfo, err := os.Lstat(filenames[l-i])
if err != nil {
fmt.Fprintf(os.Stderr, "Error getting file info for '%s': %v\n", filenames[l-i], err)
defer os.Exit(1)
continue
}
isadir := fileinfo.IsDir()
if *prompteach || *promptonce && (l-i)%3 == 1 {
promptno = coreutils.PromptFunc(filenames[l-i], true)
}
if !promptno {
continue
}
if !*emptydir && !*recurse && isadir {
fmt.Fprintf(os.Stderr, "Could not remove '%s': Is a directory\n", filenames[l-i])
defer os.Exit(1)
continue
}
if *verbose {
fmt.Printf("Removing '%s'\n", filenames[l-i])
}
err = os.Remove(filenames[l-i])
if err != nil && !(*force && os.IsNotExist(err)) {
fmt.Fprintf(os.Stderr, "Could not remove '%s': %v\n", filenames[l-i], err)
defer os.Exit(1)
}
}
return
}
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Mv"
goopt.Summary = "Move (rename) each SOURCE to DEST"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... SOURCE(...) DEST\n or:\t%s [OPTION]... -t DEST SOURCE\n", os.Args[0], os.Args[0]) + goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
prompt := goopt.Flag([]string{"-i", "--interactive"}, nil, "Prompt before an overwrite. Override -f and -n.", "")
noclobber := goopt.Flag([]string{"-n", "--no-clobber"}, []string{"-f", "--force"}, "Do not overwrite", "Never prompt before an overwrite")
backup := goopt.Flag([]string{"-b", "--backup"}, nil, "Backup files before overwriting", "")
goopt.OptArg([]string{"-S", "--suffix"}, "SUFFIX", "Override the usual backup suffix", coreutils.SetBackupSuffix)
goopt.OptArg([]string{"-t", "--target"}, "TARGET", "Set the target with a flag instead of at the end", coreutils.SetTarget)
update := goopt.Flag([]string{"-u", "--update"}, nil, "Move only when DEST is missing or older than SOURCE", "")
verbose := goopt.Flag([]string{"-v", "--verbose"}, nil, "Output each file as it is processed", "")
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if len(goopt.Args) < 2 {
coreutils.PrintUsage()
}
if coreutils.Target == "" {
coreutils.Target = goopt.Args[len(goopt.Args)-1]
}
destinfo, err := os.Lstat(coreutils.Target)
if err != nil && !os.IsNotExist(err) {
fmt.Fprintf(os.Stderr, "Error trying to get info to check if DEST is a directory: %v\n", err)
os.Exit(1)
}
isadir := err == nil && destinfo.IsDir()
if (len(goopt.Args) > 2 || (coreutils.Target != goopt.Args[len(goopt.Args)-1] && len(goopt.Args) > 1)) && !isadir {
fmt.Fprintf(os.Stderr, "Too many arguments for non-directory destination")
os.Exit(1)
}
for i := range goopt.Args[1:] {
dest := coreutils.Target
if isadir {
dest = dest + string(os.PathSeparator) + filepath.Base(goopt.Args[i])
}
destinfo, err := os.Lstat(dest)
exist := !os.IsNotExist(err)
newer := true
if err != nil && exist {
fmt.Fprintf(os.Stderr, "Error trying to get info on target: %v\n", err)
os.Exit(1)
}
if *update && exist {
srcinfo, err := os.Lstat(goopt.Args[i])
if err != nil {
fmt.Fprintf(os.Stderr, "Error trying to get mod time on SRC: %v\n", err)
os.Exit(1)
}
newer = srcinfo.ModTime().After(destinfo.ModTime())
}
if !newer {
continue
}
promptres := true
if exist {
promptres = !*noclobber
if *prompt {
promptres = coreutils.PromptFunc(dest, false)
}
if promptres && *backup {
coreutils.Backup(dest)
}
}
if promptres {
err = os.Rename(goopt.Args[i], dest)
if err != nil {
fmt.Fprintf(os.Stderr, "Error while moving '%s' to '%s': %v\n", goopt.Args[i], dest, err)
defer os.Exit(1)
continue
}
if *verbose {
fmt.Printf("%s -> %s\n", goopt.Args[i], dest)
}
}
}
return
}
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Cp"
goopt.Summary = "Copy each SOURCE to DEST"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... SOURCE(...) DEST\n or:\t%s [OPTION]... -t DEST SOURCE\n", os.Args[0], os.Args[0]) + goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
backup := goopt.Flag([]string{"-b", "--backup"}, nil, "Backup files before overwriting", "")
prompt := goopt.Flag([]string{"-i", "--interactive"}, nil, "Prompt before an overwrite. Override -f and -n.", "")
noclobber := goopt.Flag([]string{"-n", "--no-clobber"}, []string{"-f", "--force"}, "Do not overwrite", "Never prompt before an overwrite")
hardlink := goopt.Flag([]string{"-l", "--link"}, nil, "Make hard links instead of copying", "")
nodereference := goopt.Flag([]string{"-P", "--no-dereference"}, []string{"-L", "--dereference"}, "Never follow symlinks", "Always follow symlinks")
/*preserve := goopt.Flag([]string{"-p", "--preserve"}, nil, "Preserve mode, ownership and timestamp attributes", "")*/
recurse := goopt.Flag([]string{"-r", "-R", "--recurse"}, nil, "Recursively copy files from SOURCE to TARGET", "")
goopt.OptArg([]string{"-S", "--suffix"}, "SUFFIX", "Override the usual backup suffix", setBackupSuffix)
symlink := goopt.Flag([]string{"-s", "--symbolic-link"}, nil, "Make symlinks instead of copying", "")
goopt.OptArg([]string{"-t", "--target"}, "TARGET", "Set the target with a flag instead of at the end", setTarget)
update := goopt.Flag([]string{"-u", "--update"}, nil, "Move only when DEST is missing or older than SOURCE", "")
verbose := goopt.Flag([]string{"-v", "--verbose"}, nil, "Output each file as it is processed", "")
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if len(goopt.Args) < 2 {
coreutils.PrintUsage()
}
coreutils.Noderef = *nodereference
j := 0
if target == "" {
target = goopt.Args[len(goopt.Args)-1]
j = 1
}
var sources []string
for i := range goopt.Args[j:] {
sources = append(sources, goopt.Args[i])
if *recurse {
if coreutils.Recurse(&sources) {
defer os.Exit(1)
}
}
}
destinfo, err := coreutils.Stat(target)
if err != nil && !os.IsNotExist(err) {
fmt.Fprintf(os.Stderr, "Error trying to get info to check if DEST is a directory: %v\n", err)
os.Exit(1)
}
isadir := err == nil && destinfo.IsDir()
if (len(goopt.Args) > 2 || (target != goopt.Args[len(goopt.Args)-1] && len(goopt.Args) > 1)) && !isadir {
fmt.Fprintf(os.Stderr, "Too many arguments for non-directory destination")
os.Exit(1)
}
for i := range sources {
dest := target
if sources[i] == "" {
continue
}
destinfo, err := coreutils.Stat(target)
exist := !os.IsNotExist(err)
if err != nil && exist {
fmt.Fprintf(os.Stderr, "Error trying to get info on target: %v\n", err)
os.Exit(1)
}
srcinfo, err := coreutils.Stat(sources[i])
if err != nil {
fmt.Fprintf(os.Stderr, "Error trying to get mod time on SRC: %v\n", err)
os.Exit(1)
}
mkdir := false
if srcinfo.IsDir() {
if isadir {
dest = dest + string(os.PathSeparator) + sources[i]
}
if !*recurse {
fmt.Printf("Skipping directory %s\n", sources[i])
continue
}
mkdir = true
} else if isadir {
dest = dest + string(os.PathSeparator) + filepath.Base(sources[i])
}
newer := true
if *update && exist {
newer = srcinfo.ModTime().After(destinfo.ModTime())
}
if !newer {
continue
}
promptres := true
if exist {
promptres = !*noclobber
if *prompt {
promptres = coreutils.PromptFunc(dest, false)
}
if promptres && *backup {
if err = os.Rename(dest, dest+backupsuffix); err != nil {
fmt.Fprintf(os.Stderr, "Error while backing up '%s' to '%s': %v\n", dest, dest+backupsuffix, err)
defer os.Exit(1)
continue
}
}
}
if !promptres {
continue
}
switch {
case mkdir:
if err = os.Mkdir(dest, coreutils.Mode); err != nil {
fmt.Fprintf(os.Stderr, "Error while making directory '%s': %v\n", dest, err)
defer os.Exit(1)
continue
}
if *verbose {
fmt.Printf("Copying directory '%s' to '%s'\n", sources[i], dest)
}
case *hardlink:
if err := os.Link(sources[i], dest); err != nil {
fmt.Fprintf(os.Stderr, "Error while linking '%s' to '%s': %v\n", dest, sources[i], err)
defer os.Exit(1)
continue
}
if *verbose {
fmt.Printf("Linked '%s' to '%s'\n", dest, sources[i])
}
case *symlink:
if err := os.Symlink(sources[i], dest); err != nil {
fmt.Fprintf(os.Stderr, "Error while linking '%s' to '%s': %v\n", dest, sources[i], err)
defer os.Exit(1)
continue
}
if *verbose {
fmt.Printf("Symlinked '%s' to '%s'\n", dest, sources[i])
}
default:
source, err := os.Open(sources[i])
if err != nil {
fmt.Fprintf(os.Stderr, "Error while opening source file '%s': %v\n", sources[i], err)
defer os.Exit(1)
continue
}
filebuf, err := ioutil.ReadAll(source)
if err != nil {
fmt.Fprintf(os.Stderr, "Error while reading source file, '%s', for copying: %v\n", sources[i], err)
defer os.Exit(1)
continue
}
destfile, err := os.Create(dest)
if err != nil {
fmt.Fprintf(os.Stderr, "Error while creating destination file, '%s': %v\n", dest, err)
defer os.Exit(1)
continue
}
destfile.Write(filebuf)
if *verbose {
fmt.Printf("'%s' copied to '%s'\n", sources[i], dest)
}
}
}
return
}
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Chown"
goopt.Summary = "Change owner or group of each FILE to OWNER or GROUP\nWith reference, change owner and group of each FILE to the owner and group of RFILE"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... [OWNER][:[GROUP]] FILE...\n or:\t%s [OPTION]... --reference=RFILE FILE...\n", os.Args[0], os.Args[0], os.Args[0]) +
goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
changes := goopt.Flag([]string{"-c", "--changes"}, nil, "Like verbose but only report changes", "")
silent := goopt.Flag([]string{"-f", "--silent", "--quiet"}, nil, "Suppress most error messages", "")
verbose := goopt.Flag([]string{"-v", "--verbose"}, nil, "Output each file as it is processed", "")
nodereference := goopt.Flag([]string{"-h", "--no-dereference"}, []string{"--derference"}, "Affect symbolic links directly instead of dereferencing them", "Dereference symbolic links before operating on them (This is default)")
preserveroot := goopt.Flag([]string{"--preserve-root"}, []string{"--no-preserve-root"}, "Don't recurse on '/'", "Treat '/' normally (This is default)")
goopt.OptArg([]string{"--reference"}, "RFILE", "Use RFILE's owner and group", fromReference)
recurse := goopt.Flag([]string{"-R", "--recursive"}, nil, "Operate recursively on files and directories", "")
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if len(goopt.Args) == 0 {
coreutils.PrintUsage()
}
if !usingreference {
usergroup := strings.Split(goopt.Args[0], ":")
owner, err := user.Lookup(usergroup[0])
if err != nil {
uid = -1
} else {
uid, err = strconv.Atoi(owner.Uid)
if err != nil && !*silent {
}
/* hack until Go matures */
gid, err = strconv.Atoi(owner.Gid)
if err != nil && !*silent {
/* stuff */
}
}
}
for j := range goopt.Args[1:] {
filenames := []string{goopt.Args[j+1]}
for h := 0; h < len(filenames); h++ {
/* Fix to only print when changes occur for *changes */
if *changes || *verbose {
fmt.Printf("Modifying ownership of %s\n", filenames[h])
}
if *nodereference {
os.Lchown(filenames[h], uid, gid)
} else {
os.Chown(filenames[h], uid, gid)
}
if *recurse && (!*preserveroot || filenames[h] != "/") {
filelisting, err := ioutil.ReadDir(filenames[h])
if err != nil {
fmt.Fprintf(os.Stderr, "Could not recurse into '%s'\n", filenames[h])
defer os.Exit(1)
continue
}
for g := range filelisting {
filenames = append(filenames, filelisting[g].Name())
}
}
}
}
return
}
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Du"
goopt.Summary = "Estimate file sizes"
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... [FILE]...\n or:\t%s [OPTION]... --files0-from=F\n", os.Args[0], os.Args[0]) + goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
null := goopt.Flag([]string{"-0", "--null"}, nil, "End output with \\0 instead of \\n", "")
all := goopt.Flag([]string{"-a", "--all"}, nil, "Write counts for all files instead of only directories", "")
goopt.OptArg([]string{"-B", "--block-size"}, "SIZE", "Set the block size that is used when printing.", setBlockSize)
/*bytes := goopt.Flag([]string{"-b", "--bytes"}, nil, "Equivalent to --block-size=1", "")*/
/*total := goopt.Flag([]string{"-c", "--total"}, nil, "Add up all the sizes to create a total", "")*/
derefargs := goopt.Flag([]string{"-D", "--dereference-args", "-H"}, nil, "Dereference symlinks if they are a commandline argument", "")
goopt.OptArg([]string{"-d", "--max-depth"}, "N", "Print total for directory that is N or fewer levels deep", setMaxDepth)
goopt.OptArg([]string{"--files0-from"}, "F", "Use \\0 terminated file names from file F as commandline arguments", setFile0From)
human = goopt.Flag([]string{"-h", "--human-readable"}, nil, "Output using human readable suffices", "")
/*kilo := goopt.Flag([]string{"-k"}, nil, "Equivalent to --block-size=1K", "")*/
dereference := goopt.Flag([]string{"-L", "--dereference"}, []string{"-P", "--no-dereference"}, "Dereference symbolic links", "Do not dereference any symbolic links (this is default)")
separate := goopt.Flag([]string{"-S", "--separate-dirs"}, nil, "Do not add subdirectories to a directory's size", "")
summarize := goopt.Flag([]string{"-s", "--summarize"}, nil, "Display totals only for each argument", "")
goopt.OptArg([]string{"-t", "--threshold"}, "SIZE", "Only include entries whose size is greater than or equal to SIZE", setThreshold)
/* Time and Exclude options go here */
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if *null {
lastchar = "\0000"
}
if len(goopt.Args) == 0 {
goopt.Args = append([]string{}, ".")
}
if *all && *summarize {
fmt.Fprintf(os.Stderr, "Cannot both summarize and display all. Pick ONE.\n")
coreutils.PrintUsage()
}
sysblocksize := int64(1)
kiloconst := int64(1)
for i := range goopt.Args {
fileinfo := Stat(goopt.Args[i], *dereference, *derefargs, true)
if sysblocksize == 1 && fileinfo.Mode < 32768 {
sizeperblock := int64(fileinfo.Size) / int64(fileinfo.Blocks)
sysblocksize := int64(1)
for sysblocksize < sizeperblock {
sysblocksize *= 2
}
if sysblocksize < 1024 {
kiloconst = 1024 / sysblocksize
}
}
deeper := append([]string{}, goopt.Args[i])
coreutils.Recurse(&deeper)
orig := true
startdepth := len(strings.Split(goopt.Args[i], string(os.PathSeparator)))
foldertosize := make(map[string]int64)
deepest := startdepth
maxdepth += startdepth
for j := range deeper {
foldertosize[filepath.Dir(filepath.Clean(deeper[j]))] = 0
if len(strings.Split(deeper[j], string(os.PathSeparator))) > deepest {
deepest = len(strings.Split(deeper[j], string(os.PathSeparator)))
}
}
for deepest >= startdepth {
for j := range deeper {
if len(strings.Split(deeper[j], string(os.PathSeparator))) != deepest {
continue
}
fileinfo = Stat(deeper[j], *dereference, *derefargs, orig)
if fileinfo.Mode > 32768 {
foldertosize[filepath.Dir(filepath.Clean(deeper[j]))] += fileinfo.Blocks / kiloconst
if maxdepth != startdepth && maxdepth < deepest {
continue
}
if *all {
fmt.Printf("%s\t%s%s", fmtSize(fileinfo.Blocks/2), deeper[j], lastchar)
}
} else {
foldertosize[filepath.Clean(deeper[j])] += fileinfo.Blocks / kiloconst
if !*separate && filepath.Dir(filepath.Clean(deeper[j])) != filepath.Clean(deeper[j]) {
foldertosize[filepath.Dir(filepath.Clean(deeper[j]))] += foldertosize[filepath.Clean(deeper[j])]
}
if *summarize || (maxdepth < deepest && maxdepth != startdepth) {
continue
}
fmt.Printf("%s\t%s%s", fmtSize(foldertosize[filepath.Clean(deeper[j])]), deeper[j], lastchar)
}
}
deepest--
}
if *summarize {
fmt.Printf("%s\t%s%s", fmtSize(foldertosize[filepath.Dir(filepath.Clean(goopt.Args[i]))]), goopt.Args[i], lastchar)
}
}
return
}
func main() {
goopt.Author = "William Pearson"
goopt.Version = "Ln"
goopt.Summary = "Make a LINK (whose name is optionally specified) to TARGET or make a link in DIRECTORY to each TARGET."
goopt.Usage = func() string {
return fmt.Sprintf("Usage:\t%s [OPTION]... TARGET (LINK)\n or:\t%s [OPTION]... TARGET... DIRECTORY\n or:\t%s [OPTION]... -t DIRECTORY TARGET...\n", os.Args[0], os.Args[0]) + goopt.Summary + "\n\n" + goopt.Help()
}
goopt.Description = func() string {
return goopt.Summary + "\n\nUnless --help or --version is passed."
}
backup := goopt.Flag([]string{"-b", "--backup"}, nil, "Backup files before overwriting", "")
prompt := goopt.Flag([]string{"-i", "--interactive"}, nil, "Prompt before removing any existing files.", "")
force := goopt.Flag([]string{"-f", "--force"}, nil, "Remove existing files which match link names", "")
directories := goopt.Flag([]string{"-d", "-F", "--directory"}, nil, "Allow attempts to hard link directories", "")
nodereference := goopt.Flag([]string{"-n", "--no-dereference"}, nil, "treat LINK as a normal file if it is a symbolic link", "")
logical := goopt.Flag([]string{"-L", "--logical"}, []string{"-P", "--physical"}, "Dereference TARGET if it is a symbolic link", "Make hard links directly to symbolic links. (this is default)")
relative := goopt.Flag([]string{"-r", "--relative"}, nil, "Make symbolic links relative to link location", "")
symbolic := goopt.Flag([]string{"-s", "--symbolic"}, nil, "Make symbolic links rather than hard links", "")
goopt.OptArg([]string{"-S", "--suffix"}, "SUFFIX", "Override the usual backup suffix", coreutils.SetBackupSuffix)
goopt.OptArg([]string{"-t", "--target"}, "TARGET", "Set the target with a flag instead of at the end", coreutils.SetTarget)
verbose := goopt.Flag([]string{"-v", "--verbose"}, nil, "Output each file as it is processed", "")
goopt.NoArg([]string{"--version"}, "outputs version information and exits", coreutils.Version)
goopt.Parse(nil)
if len(goopt.Args) < 2 {
coreutils.PrintUsage()
}
coreutils.Noderef = *nodereference
i := 0
isadir := false
exists := false
if coreutils.Target == "" {
if len(goopt.Args) > 1 {
i = 1
coreutils.Target = goopt.Args[len(goopt.Args)-1]
} else {
coreutils.Target = filepath.Base(goopt.Args[0])
}
} else {
isadir = true
}
fileinfo, err := coreutils.Stat(coreutils.Target)
if err != nil && !os.IsNotExist(err) {
fmt.Fprintf(os.Stderr, "Error getting file info for '%s': %v\n", coreutils.Target, err)
os.Exit(1)
}
if err == nil {
exists = true
if fileinfo.IsDir() {
isadir = true
}
}
for j := range goopt.Args[i:] {
coreutils.Noderef = !*logical
fileinfo, err = coreutils.Stat(goopt.Args[j])
if err != nil && !os.IsNotExist(err) {
fmt.Fprintf(os.Stderr, "Error getting file info for '%s': %v\n", goopt.Args[j], err)
defer os.Exit(1)
continue
}
if err == nil && !*symbolic && !*directories && fileinfo.IsDir() {
fmt.Fprintf(os.Stderr, "Attempt to hard link a directory")
defer os.Exit(1)
continue
}
coreutils.Noderef = *nodereference
dest := coreutils.Target
if isadir {
dest = dest + filepath.Base(goopt.Args[j])
fileinfo, err = coreutils.Stat(dest)
if err != nil && !os.IsNotExist(err) {
fmt.Fprintf(os.Stderr, "Error getting file info for '%s': %v\n", dest, err)
defer os.Exit(1)
continue
}
if err == nil {
exists = true
}
}
promptno := true
if exists {
if *backup {
coreutils.Backup(dest)
}
if *force {
os.Remove(dest)
} else if *prompt {
promptno = coreutils.PromptFunc(dest, false)
if promptno {
os.Remove(dest)
}
}
if !*relative {
dest, err = filepath.Abs(dest)
if err != nil {
fmt.Fprintf(os.Stderr, "Error making absolute path from '%s'", dest, err)
}
}
}
if !promptno {
exists = false
continue
}
if *symbolic {
os.Symlink(goopt.Args[j], dest)
} else {
os.Link(goopt.Args[j], dest)
}
if *verbose {
fmt.Printf("'%s' -> '%s'\n", dest, goopt.Args[j])
}
exists = false
}
return
}