Ошибка сегментации Голанга (ядро сбрасывается)

Question

Я новичок в голанге и программировании.

Я написал небольшую программу, которая перемещает файлы, соответствующие регулярному выражению из одного каталога в другой.

Программа успешно работает на Ubuntu 16,04 и на Centos 6.8 (Final)

На определенной машине Centos (я не знаю точную версию того. Я знаю, что это 6.? И она ниже, чем 6,8), я получаю:

вина Сегментация (ядро сбрасывали)

Мои исследования показывают, что эта ошибка возникает, когда операционная система не позволяет мне получить доступ к памяти.

Может кто-нибудь сказать мне, где это пойдет не так в моем коде. Также, пожалуйста, указывайте на неправильные методы, если увидите.

package main 

import (
    "flag" 
    "fmt" 
    "log" 
    "os" 
    "regexp" 
    "strings" 
) 

func main() { 

    batch := flag.Int("batch", 0, "the amount of files to be processed") 
    pattern := flag.String("pattern", "", "string pattern to be matched") 
    dir := flag.Int("dir", 0, "key from strings.Split(pattern, '')") 
    confirm := flag.String("move", "no", "flags if program should move files") 

    flag.Parse() 

    d, err := os.Open(".") 
    if err != nil { 
     log.Fatal("Could not open directory. ", err) 
    } 

    files, err := d.Readdir(*batch) 
    if err != nil { 
     log.Fatal("Could not read directory. ", err) 
    } 

    for _, file := range files { 
     fname := file.Name() 
     match, err := regexp.Match(*pattern, []byte(fname)) 
     if err != nil { 
      log.Fatal(err) 
     } 
     if match == true { 

      s := strings.Split(fname, "_") 
      dest := s[*dir] 

      switch *confirm { 
      case "no": 
       fmt.Printf(" %s matches %s\n Dir name = %s\n -----------------------\n", fname, *pattern, dest) 

      case "yes": 
       //all directories are expected to be a number. 
       //terminate execution if directory doesn't match regex 
       if match, err := regexp.Match("[0-9]", []byte(dest)); match == false { 
        log.Fatalf("Expected directory name does not match prepared directory.\n Expected dir name must be a number (regex [0-9]) | Current dir name is: %s\n", dest) 
        if err != nil { 
         log.Fatal(err) 
        } 
       } 

       //check if direcotry exists. create it if it doesn't 
       if _, err := os.Stat(dest); os.IsNotExist(err) { 
        err = os.Mkdir(dest, 0777) 
        if err != nil { 
         log.Fatal("Could not create directory. ", err) 
        } 
       } 
       err = os.Rename(fname, fmt.Sprintf("%s/%s", dest, fname)) 
       if err != nil { 
        log.Fatal("Could not move file. ", err) 
       } 
       fmt.Printf("Moved %s to %s\n", fname, dest) 
      } 
     } 
    } 
    fmt.Println("Exit") 
} 

Answer 1

Моя первая догадка бы вы более выполняющихся границы в 'S' массива:

dest := s[*dir] 

Я добавил некоторые проверки безопасности (см [Добавлено]):

package main 

import (
    "flag" 
    "fmt" 
    "log" 
    "os" 
    "regexp" 
    "strings" 
) 

func main() { 
    batch := flag.Int("batch", 0, "the amount of files to be processed") 
    pattern := flag.String("pattern", "", "string pattern to be matched") 
    dir := flag.Int("dir", 0, "key from strings.Split(pattern, '')") 
    confirm := flag.String("move", "no", "flags if program should move files") 

    flag.Parse() 

    d, err := os.Open(".") 
    if err != nil { 
     log.Fatal("Could not open directory. ", err) 
    } 
    defer d.Close() // [Added] probably not needed if a directory but doesn't hurt 

    files, err := d.Readdir(*batch) 
    if err != nil { 
     log.Fatal("Could not read directory. ", err) 
    } 

    for _, file := range files { 
     fname := file.Name() 
     match, err := regexp.Match(*pattern, []byte(fname)) 
     if err != nil { 
      log.Fatal(err) 
     } 
     if match == true { 
      s := strings.Split(fname, "_") 

      // [Added] Sanity check *dir index before using 
      if *dir >= len(s) { 
       log.Fatalf("dir is out of range: dir=%d len(s)=%d\n", *dir, len(s)) 
      } 

      dest := s[*dir] 

      switch *confirm { 
      case "no": 
       fmt.Printf(" %s matches %s\n Dir name = %s\n -----------------------\n", fname, *pattern, dest) 

      case "yes": 
       //all directories are expected to be a number. 
       //terminate execution if directory doesn't match regex 
       if match, err := regexp.Match("[0-9]", []byte(dest)); match == false { 
        log.Fatalf("Expected directory name does not match prepared directory.\n Expected dir name must be a number (regex [0-9]) | Current dir name is: %s\n", dest) 
        if err != nil { 
         log.Fatal(err) 
        } 
       } 

       //check if direcotry exists. create it if it doesn't 
       if _, err := os.Stat(dest); os.IsNotExist(err) { 
        err = os.Mkdir(dest, 0777) 
        if err != nil { 
         log.Fatal("Could not create directory. ", err) 
        } 
       } 
       err = os.Rename(fname, fmt.Sprintf("%s/%s", dest, fname)) 
       if err != nil { 
        log.Fatal("Could not move file. ", err) 
       } 
       fmt.Printf("Moved %s to %s\n", fname, dest) 

       // [Added]: Make sure to handle non 'yes/no' answers 
      default: 
       log.Fatalf("confirm is invalid '%s'\n", *confirm) 
      } 
     } 
    } 
    fmt.Println("Exit") 
} 

Не знаете, что вы вводите в программу, но ничего больше, что я вижу, может вызвать ошибку сегментации.