_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q172600 | Contain | validation | func Contain(filename string, b []byte) (bool, error) {
f, err := os.Open(filename)
if err != nil {
return false, fmt.Errorf("Contain: %s", err)
}
defer f.Close()
buf := bufio.NewReader(f)
for {
line, err := buf.ReadBytes('\n')
if err == io.EOF {
break
}
if bytes.Contains(line, b) {
return true,... | go | {
"resource": ""
} |
q172601 | ContainString | validation | func ContainString(filename, s string) (bool, error) {
f, err := os.Open(filename)
if err != nil {
return false, fmt.Errorf("ContainString: %s", err)
}
defer f.Close()
buf := bufio.NewReader(f)
for {
line, err := buf.ReadString('\n')
if err == io.EOF {
break
}
if strings.Contains(line, s) {
retu... | go | {
"resource": ""
} |
q172602 | init | validation | func init() {
log.SetFlags(0)
log.SetPrefix("ERROR: ")
if BOOT {
_ENV = []string{"PATH=" + PATH} // from file boot
} else {
_ENV = os.Environ()
_HOME = os.Getenv("HOME")
}
/*if path := os.Getenv("PATH"); path == "" {
if err = os.Setenv("PATH", PATH); err != nil {
log.Print(err)
}
}*/
} | go | {
"resource": ""
} |
q172603 | StartLogger | validation | func StartLogger() {
var err error
if BOOT {
if logFile, err = os.OpenFile(_LOG_FILE, os.O_WRONLY|os.O_TRUNC, 0); err != nil {
log.Print(err)
} else {
Log = log.New(logFile, "", log.Lshortfile)
}
} else {
if Log, err = syslog.NewLogger(syslog.LOG_NOTICE, log.Lshortfile); err != nil {
log.Fatal(err)... | go | {
"resource": ""
} |
q172604 | openDBFile | validation | func openDBFile(filename string, flag int) (*dbfile, error) {
f, err := os.OpenFile(filename, flag, 0)
if err != nil {
return nil, err
}
db := &dbfile{file: f, rd: bufio.NewReader(f)}
db.Lock()
return db, nil
} | go | {
"resource": ""
} |
q172605 | backup | validation | func backup(filename string) error {
if DO_BACKUP {
if _, ok := _FILES_BACKUPED[filename]; !ok {
if err := file.Backup(filename); err != nil {
return err
}
_FILES_BACKUPED[filename] = struct{}{}
}
}
return nil
} | go | {
"resource": ""
} |
q172606 | New | validation | func New(pkg PackageType) Packager {
switch pkg {
case Deb:
return new(deb)
case RPM:
return new(rpm)
case Pacman:
return new(pacman)
case Ebuild:
return new(ebuild)
case ZYpp:
return new(zypp)
}
panic("unreachable")
} | go | {
"resource": ""
} |
q172607 | RegisterCrypt | validation | func RegisterCrypt(c Crypt, f func() Crypter, prefix string) {
if c >= maxCrypt {
panic("crypt: RegisterHash of unknown crypt function")
}
crypts[c] = f
cryptPrefixes[c] = prefix
} | go | {
"resource": ""
} |
q172608 | New | validation | func New(c Crypt) Crypter {
f := crypts[c]
if f != nil {
return f()
}
panic("crypt: requested crypt function is unavailable")
} | go | {
"resource": ""
} |
q172609 | NewFromHash | validation | func NewFromHash(hashedKey string) Crypter {
var f func() Crypter
if strings.HasPrefix(hashedKey, cryptPrefixes[SHA512]) {
f = crypts[SHA512]
} else if strings.HasPrefix(hashedKey, cryptPrefixes[SHA256]) {
f = crypts[SHA256]
} else if strings.HasPrefix(hashedKey, cryptPrefixes[MD5]) {
f = crypts[MD5]
} else... | go | {
"resource": ""
} |
q172610 | Text | validation | func (s *Scanner) Text() (key, value string) {
return string(s.key), string(s.value)
} | go | {
"resource": ""
} |
q172611 | Exec | validation | func Exec(cmd string, args ...string) error {
c := exec.Command(cmd, args...)
c.Stdin = os.Stdin
c.Stdout = os.Stdout
c.Stderr = os.Stderr
if err := c.Run(); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q172612 | ExecSudo | validation | func ExecSudo(cmd string, args ...string) error {
return Exec("sudo", append([]string{cmd}, args...)...)
} | go | {
"resource": ""
} |
q172613 | nextUID | validation | func nextUID(isSystem bool) (db *dbfile, uid int, err error) {
loadConfig()
db, err = openDBFile(_USER_FILE, os.O_RDWR)
if err != nil {
return
}
// Seek to file half size.
info, err := db.file.Stat()
if err != nil {
db.close()
return nil, 0, err
}
if _, err = db.file.Seek(info.Size()/2, os.SEEK_SET); ... | go | {
"resource": ""
} |
q172614 | nextGUID | validation | func nextGUID(isSystem bool) (db *dbfile, gid int, err error) {
loadConfig()
db, err = openDBFile(_GROUP_FILE, os.O_RDWR)
if err != nil {
return
}
// Seek to file half size.
info, err := db.file.Stat()
if err != nil {
db.close()
return nil, 0, err
}
if _, err = db.file.Seek(info.Size()/2, os.SEEK_SET)... | go | {
"resource": ""
} |
q172615 | NextSystemUID | validation | func NextSystemUID() (int, error) {
db, uid, err := nextUID(true)
db.close()
return uid, err
} | go | {
"resource": ""
} |
q172616 | NextSystemGID | validation | func NextSystemGID() (int, error) {
db, gid, err := nextGUID(true)
db.close()
return gid, err
} | go | {
"resource": ""
} |
q172617 | NextUID | validation | func NextUID() (int, error) {
db, uid, err := nextUID(false)
db.close()
return uid, err
} | go | {
"resource": ""
} |
q172618 | NextGID | validation | func NextGID() (int, error) {
db, gid, err := nextGUID(false)
db.close()
return gid, err
} | go | {
"resource": ""
} |
q172619 | NewShadow | validation | func NewShadow(username string) *Shadow {
loadConfig()
return &Shadow{
Name: username,
changed: _ENABLE_AGING,
Min: config.login.PASS_MIN_DAYS,
Max: config.login.PASS_MAX_DAYS,
Warn: config.login.PASS_WARN_AGE,
}
} | go | {
"resource": ""
} |
q172620 | parseShadow | validation | func parseShadow(row string) (*Shadow, error) {
fields := strings.Split(row, ":")
if len(fields) != 9 {
return nil, rowError{_SHADOW_FILE, row}
}
var inactive, expire, flag int
changed, err := parseChange(fields[2])
if err != nil {
return nil, atoiError{_SHADOW_FILE, row, "changed"}
}
min, err := strconv.... | go | {
"resource": ""
} |
q172621 | LookupShadow | validation | func LookupShadow(name string) (*Shadow, error) {
entries, err := LookupInShadow(S_NAME, name, 1)
if err != nil {
return nil, err
}
return entries[0], err
} | go | {
"resource": ""
} |
q172622 | Add | validation | func (s *Shadow) Add(key []byte) (err error) {
loadConfig()
shadow, err := LookupShadow(s.Name)
if err != nil {
if _, ok := err.(NoFoundError); !ok {
return
}
}
if shadow != nil {
return ErrUserExist
}
if s.Name == "" {
return RequiredError("Name")
}
if s.Max == 0 {
return RequiredError("Max")
... | go | {
"resource": ""
} |
q172623 | Copy | validation | func Copy(source, dest string) (err error) {
// Don't backup files of backup.
if dest[len(dest)-1] != '~' {
if err = Backup(dest); err != nil {
return
}
}
srcFile, err := os.Open(source)
if err != nil {
return err
}
defer func() {
err2 := srcFile.Close()
if err2 != nil && err == nil {
err = err2... | go | {
"resource": ""
} |
q172624 | Create | validation | func Create(filename string, b []byte) (err error) {
file, err := os.Create(filename)
if err != nil {
return err
}
_, err = file.Write(b)
err2 := file.Close()
if err2 != nil && err == nil {
err = err2
}
return
} | go | {
"resource": ""
} |
q172625 | loadConfig | validation | func loadConfig() {
config.Do(func() {
//checkRoot()
if err := config.init(); err != nil {
panic(err)
}
})
} | go | {
"resource": ""
} |
q172626 | NewEdit | validation | func NewEdit(filename string) (*edit, error) {
if err := Backup(filename); err != nil {
return nil, err
}
file, err := os.OpenFile(filename, os.O_RDWR, 0666)
if err != nil {
return nil, err
}
return &edit{
_editDefault,
file,
bufio.NewReadWriter(bufio.NewReader(file), bufio.NewWriter(file)),
}, nil
} | go | {
"resource": ""
} |
q172627 | AppendString | validation | func (e *edit) AppendString(s string) error {
return e.Append([]byte(s))
} | go | {
"resource": ""
} |
q172628 | Comment | validation | func (e *edit) Comment(reLine []string) error {
allReSearch := make([]*regexp.Regexp, len(reLine))
for i, v := range reLine {
if re, err := regexp.Compile(v); err != nil {
return err
} else {
allReSearch[i] = re
}
}
if _, err := e.file.Seek(0, os.SEEK_SET); err != nil {
return err
}
char := []byt... | go | {
"resource": ""
} |
q172629 | CommentOut | validation | func (e *edit) CommentOut(reLine []string) error {
allSearch := make([]ReplacerAtLine, len(reLine))
for i, v := range reLine {
allSearch[i] = ReplacerAtLine{
v,
"[[:space:]]*" + e.CommentChar + "[[:space:]]*",
"",
}
}
return e.ReplaceAtLineN(allSearch, 1)
} | go | {
"resource": ""
} |
q172630 | CommentM | validation | func CommentM(filename string, reLine []string) error {
e, err := NewEdit(filename)
if err != nil {
return err
}
err = e.Comment(reLine)
err2 := e.Close()
if err != nil {
return err
}
return err2
} | go | {
"resource": ""
} |
q172631 | CommentOutM | validation | func CommentOutM(filename string, reLine []string) error {
e, err := NewEdit(filename)
if err != nil {
return err
}
err = e.CommentOut(reLine)
err2 := e.Close()
if err != nil {
return err
}
return err2
} | go | {
"resource": ""
} |
q172632 | ReplaceN | validation | func ReplaceN(filename string, r []Replacer, n int) error {
e, err := NewEdit(filename)
if err != nil {
return err
}
err = e.genReplace(r, n)
err2 := e.Close()
if err != nil {
return err
}
return err2
} | go | {
"resource": ""
} |
q172633 | ReplaceAtLine | validation | func ReplaceAtLine(filename string, r []ReplacerAtLine) error {
e, err := NewEdit(filename)
if err != nil {
return err
}
err = e.genReplaceAtLine(r, -1)
err2 := e.Close()
if err != nil {
return err
}
return err2
} | go | {
"resource": ""
} |
q172634 | ReplaceAtLineN | validation | func ReplaceAtLineN(filename string, r []ReplacerAtLine, n int) error {
e, err := NewEdit(filename)
if err != nil {
return err
}
err = e.genReplaceAtLine(r, n)
err2 := e.Close()
if err != nil {
return err
}
return err2
} | go | {
"resource": ""
} |
q172635 | init | validation | func init() {
var err error
_SETTINGS, err = getSettingsForUid(os.Getuid())
if err != nil {
panic(err)
}
} | go | {
"resource": ""
} |
q172636 | getSettingsForUid | validation | func getSettingsForUid(id int) (settings, error) {
u, err := user.LookupUID(id)
if err != nil {
return settings{}, err
}
if u.Shell == "" {
return settings{}, NoShellError(u.Name)
}
if u.Dir == "" {
return settings{}, NoHomeError(u.Name)
}
shell := path.Base(u.Shell)
_settings := settings{
global: sy... | go | {
"resource": ""
} |
q172637 | _Set | validation | func _Set(filename, key, value string) error {
// Check if the key is already used.
conf, err := shconf.ParseFile(filename)
if err != nil {
if err != os.ErrNotExist {
return err
}
println("ErrNotExist") //TODO: remove
} else {
if _, err = conf.Get(key); err != shconf.ErrKey {
panic("OPS")
}
}
ret... | go | {
"resource": ""
} |
q172638 | _MSet | validation | func _MSet(filename string, keys, values []string) error {
if len(keys) != len(values) {
return fmt.Errorf("number of keys is different to number of values")
}
// Check if the key is already used.
conf, err := shconf.ParseFile(filename)
if err != nil {
if err != os.ErrNotExist {
return err
}
println("E... | go | {
"resource": ""
} |
q172639 | Set | validation | func Set(key, value string) error {
err := _Set(_SETTINGS.user, key, value)
if err != nil {
return err
}
if _SETTINGS.useKDE {
return _Set(_SETTINGS.kde, key, value)
}
return nil
} | go | {
"resource": ""
} |
q172640 | MSet | validation | func MSet(keys, values []string) error {
err := _MSet(_SETTINGS.user, keys, values)
if err != nil {
return err
}
if _SETTINGS.useKDE {
return _MSet(_SETTINGS.kde, keys, values)
}
return nil
} | go | {
"resource": ""
} |
q172641 | SetForUid | validation | func SetForUid(id int, key, value string) error {
_settings, err := getSettingsForUid(id)
if err != nil {
return err
}
if err = _Set(_settings.user, key, value); err != nil {
return err
}
if _settings.useKDE {
return _Set(_settings.kde, key, value)
}
return nil
} | go | {
"resource": ""
} |
q172642 | MSetForUid | validation | func MSetForUid(id int, keys, values []string) error {
_settings, err := getSettingsForUid(id)
if err != nil {
return err
}
if err = _MSet(_settings.user, keys, values); err != nil {
return err
}
if _settings.useKDE {
return _MSet(_settings.kde, keys, values)
}
return nil
} | go | {
"resource": ""
} |
q172643 | Setsys | validation | func Setsys(key, value string) error {
if !_IS_ROOT {
return ErrNoRoot
}
return _Set(_SETTINGS.global, key, value)
} | go | {
"resource": ""
} |
q172644 | MSetsys | validation | func MSetsys(keys, values []string) error {
if !_IS_ROOT {
return ErrNoRoot
}
return _MSet(_SETTINGS.global, keys, values)
} | go | {
"resource": ""
} |
q172645 | SetsysForUid | validation | func SetsysForUid(id int, key, value string) error {
if !_IS_ROOT {
return ErrNoRoot
}
_settings, err := getSettingsForUid(id)
if err != nil {
return err
}
return _Set(_settings.global, key, value)
} | go | {
"resource": ""
} |
q172646 | MSetsysForUid | validation | func MSetsysForUid(id int, keys, values []string) error {
if !_IS_ROOT {
return ErrNoRoot
}
_settings, err := getSettingsForUid(id)
if err != nil {
return err
}
return _MSet(_settings.global, keys, values)
} | go | {
"resource": ""
} |
q172647 | NewGShadow | validation | func NewGShadow(username string, members ...string) *GShadow {
return &GShadow{
Name: username,
UserList: members,
}
} | go | {
"resource": ""
} |
q172648 | parseGShadow | validation | func parseGShadow(row string) (*GShadow, error) {
fields := strings.Split(row, ":")
if len(fields) != 4 {
return nil, rowError{_GSHADOW_FILE, row}
}
return &GShadow{
fields[0],
fields[1],
strings.Split(fields[2], ","),
strings.Split(fields[3], ","),
}, nil
} | go | {
"resource": ""
} |
q172649 | lookUp | validation | func (*GShadow) lookUp(line string, f field, value interface{}) interface{} {
_field := f.(gshadowField)
_value := value.(string)
allField := strings.Split(line, ":")
arrayField := make(map[int][]string)
arrayField[2] = strings.Split(allField[2], ",")
arrayField[3] = strings.Split(allField[3], ",")
// Check fi... | go | {
"resource": ""
} |
q172650 | LookupGShadow | validation | func LookupGShadow(name string) (*GShadow, error) {
entries, err := LookupInGShadow(GS_NAME, name, 1)
if err != nil {
return nil, err
}
return entries[0], err
} | go | {
"resource": ""
} |
q172651 | Add | validation | func (gs *GShadow) Add(key []byte) (err error) {
loadConfig()
gshadow, err := LookupGShadow(gs.Name)
if err != nil {
if _, ok := err.(NoFoundError); !ok {
return
}
}
if gshadow != nil {
return ErrGroupExist
}
if gs.Name == "" {
return RequiredError("Name")
}
// Backup
if err = backup(_GSHADOW_FI... | go | {
"resource": ""
} |
q172652 | NewUser | validation | func NewUser(name string, gid int) *User {
loadConfig()
return &User{
Name: name,
Dir: path.Join(config.useradd.HOME, name),
Shell: config.useradd.SHELL,
UID: -1,
GID: gid,
}
} | go | {
"resource": ""
} |
q172653 | NewSystemUser | validation | func NewSystemUser(name, homeDir string, gid int) *User {
return &User{
Name: name,
Dir: homeDir,
Shell: "/bin/false",
UID: -1,
GID: gid,
addSystemUser: true,
}
} | go | {
"resource": ""
} |
q172654 | IsOfSystem | validation | func (u *User) IsOfSystem() bool {
//loadConfig()
if u.UID > config.login.SYS_UID_MIN && u.UID < config.login.SYS_UID_MAX {
return true
}
return false
} | go | {
"resource": ""
} |
q172655 | parseUser | validation | func parseUser(row string) (*User, error) {
fields := strings.Split(row, ":")
if len(fields) != 7 {
return nil, rowError{_USER_FILE, row}
}
uid, err := strconv.Atoi(fields[2])
if err != nil {
return nil, atoiError{_USER_FILE, row, "UID"}
}
gid, err := strconv.Atoi(fields[3])
if err != nil {
return nil, a... | go | {
"resource": ""
} |
q172656 | lookUp | validation | func (*User) lookUp(line string, f field, value interface{}) interface{} {
_field := f.(userField)
allField := strings.Split(line, ":")
intField := make(map[int]int)
// Check integers
var err error
if intField[2], err = strconv.Atoi(allField[2]); err != nil {
panic(atoiError{_USER_FILE, line, "UID"})
}
if in... | go | {
"resource": ""
} |
q172657 | LookupUID | validation | func LookupUID(uid int) (*User, error) {
entries, err := LookupInUser(U_UID, uid, 1)
if err != nil {
return nil, err
}
return entries[0], err
} | go | {
"resource": ""
} |
q172658 | LookupUser | validation | func LookupUser(name string) (*User, error) {
entries, err := LookupInUser(U_NAME, name, 1)
if err != nil {
return nil, err
}
return entries[0], err
} | go | {
"resource": ""
} |
q172659 | GetUsername | validation | func GetUsername() string {
entry, err := LookupUID(os.Getuid())
if err != nil {
panic(err)
}
return entry.Name
} | go | {
"resource": ""
} |
q172660 | GetUsernameFromEnv | validation | func GetUsernameFromEnv() string {
user_env := []string{"USER", "USERNAME", "LOGNAME", "LNAME"}
for _, val := range user_env {
name := os.Getenv(val)
if name != "" {
return name
}
}
return ""
} | go | {
"resource": ""
} |
q172661 | AddUser | validation | func AddUser(name string, gid int) (uid int, err error) {
s := NewShadow(name)
if err = s.Add(nil); err != nil {
return
}
return NewUser(name, gid).Add()
} | go | {
"resource": ""
} |
q172662 | AddSystemUser | validation | func AddSystemUser(name, homeDir string, gid int) (uid int, err error) {
s := NewShadow(name)
if err = s.Add(nil); err != nil {
return
}
return NewSystemUser(name, homeDir, gid).Add()
} | go | {
"resource": ""
} |
q172663 | Add | validation | func (u *User) Add() (uid int, err error) {
loadConfig()
user, err := LookupUser(u.Name)
if err != nil {
if _, ok := err.(NoFoundError); !ok {
return
}
}
if user != nil {
return 0, ErrUserExist
}
if u.Name == "" {
return 0, RequiredError("Name")
}
if u.Dir == "" {
return 0, RequiredError("Dir")
... | go | {
"resource": ""
} |
q172664 | DelUser | validation | func DelUser(name string) (err error) {
err = del(name, &User{})
if err == nil {
err = del(name, &Shadow{})
}
return
} | go | {
"resource": ""
} |
q172665 | ParseFile | validation | func ParseFile(name string) (*Config, error) {
file, err := os.Open(name)
if err != nil {
return nil, err
}
cfg := &Config{
sync.RWMutex{},
make(map[string]string),
make([]byte, 0),
file.Name(),
}
cfg.Lock()
defer cfg.Unlock()
defer file.Close()
gotSeparator := false
s := NewScanner(file)
for fo... | go | {
"resource": ""
} |
q172666 | Print | validation | func (c *Config) Print() {
fmt.Println(c.filename)
for k, v := range c.data {
fmt.Printf("\t%s: %s\n", k, v)
}
} | go | {
"resource": ""
} |
q172667 | Getbool | validation | func (c *Config) Getbool(key string) (bool, error) {
if value, found := c.data[key]; found {
return strconv.ParseBool(value)
}
return false, ErrKey
} | go | {
"resource": ""
} |
q172668 | Getint | validation | func (c *Config) Getint(key string) (int, error) {
if value, found := c.data[key]; found {
v, err := strconv.ParseInt(value, 10, 0)
return int(v), err
}
return 0, ErrKey
} | go | {
"resource": ""
} |
q172669 | Getuint | validation | func (c *Config) Getuint(key string) (uint, error) {
if value, found := c.data[key]; found {
v, err := strconv.ParseUint(value, 10, 0)
return uint(v), err
}
return 0, ErrKey
} | go | {
"resource": ""
} |
q172670 | Getfloat | validation | func (c *Config) Getfloat(key string) (float64, error) {
if value, found := c.data[key]; found {
return strconv.ParseFloat(value, 64)
}
return 0, ErrKey
} | go | {
"resource": ""
} |
q172671 | Set | validation | func (c *Config) Set(key, value string) error {
c.Lock()
defer c.Unlock()
if _, found := c.data[key]; !found {
return ErrKey
}
separator := string(c.Separator())
replAt := []file.ReplacerAtLine{
{key + separator, separator + ".*", separator + value},
}
if err := file.ReplaceAtLine(c.filename, replAt); er... | go | {
"resource": ""
} |
q172672 | Run | validation | func Run(command string) (output []byte, err error) {
output, _, err = RunWithMatch(command)
return
} | go | {
"resource": ""
} |
q172673 | NewInfo | validation | func NewInfo(name string) (*info, error) {
i, err := os.Stat(name)
if err != nil {
return nil, err
}
return &info{i}, nil
} | go | {
"resource": ""
} |
q172674 | OwnerHas | validation | func (i *info) OwnerHas(p ...perm) bool {
mode := i.fi.Mode()
for _, v := range p {
switch v {
case R:
if mode&modeROwner == 0 {
return false
}
case W:
if mode&modeWOwner == 0 {
return false
}
case X:
if mode&modeXOwner == 0 {
return false
}
}
}
return true
} | go | {
"resource": ""
} |
q172675 | GroupHas | validation | func (i *info) GroupHas(p ...perm) bool {
mode := i.fi.Mode()
for _, v := range p {
switch v {
case R:
if mode&modeRGroup == 0 {
return false
}
case W:
if mode&modeWGroup == 0 {
return false
}
case X:
if mode&modeXGroup == 0 {
return false
}
}
}
return true
} | go | {
"resource": ""
} |
q172676 | OthersHave | validation | func (i *info) OthersHave(p ...perm) bool {
mode := i.fi.Mode()
for _, v := range p {
switch v {
case R:
if mode&modeROthers == 0 {
return false
}
case W:
if mode&modeWOthers == 0 {
return false
}
case X:
if mode&modeXOthers == 0 {
return false
}
}
}
return true
} | go | {
"resource": ""
} |
q172677 | OwnerHas | validation | func OwnerHas(name string, p ...perm) (bool, error) {
i, err := NewInfo(name)
if err != nil {
return false, err
}
return i.OwnerHas(p...), nil
} | go | {
"resource": ""
} |
q172678 | lookupCrypter | validation | func lookupCrypter() (crypt.Crypter, error) {
f, err := os.Open(_SHADOW_FILE)
if err != nil {
return nil, err
}
defer f.Close()
buf := bufio.NewReader(f)
for {
line, _, err := buf.ReadLine()
if err != nil {
if err == io.EOF {
return nil, ErrShadowPasswd
}
log.Print(err)
continue
}
sha... | go | {
"resource": ""
} |
q172679 | Passwd | validation | func (s *Shadow) Passwd(key []byte) {
loadConfig()
s.password, _ = config.crypter.Generate(key, nil)
s.setChange()
} | go | {
"resource": ""
} |
q172680 | Passwd | validation | func (gs *GShadow) Passwd(key []byte) {
loadConfig()
gs.password, _ = config.crypter.Generate(key, nil)
} | go | {
"resource": ""
} |
q172681 | ChPasswd | validation | func ChPasswd(user string, key []byte) error {
shadow, err := LookupShadow(user)
if err != nil {
return err
}
shadow.Passwd(key)
return edit(user, shadow)
} | go | {
"resource": ""
} |
q172682 | ChGPasswd | validation | func ChGPasswd(group string, key []byte) error {
gshadow, err := LookupGShadow(group)
if err != nil {
return err
}
gshadow.Passwd(key)
return edit(group, gshadow)
} | go | {
"resource": ""
} |
q172683 | LockUser | validation | func LockUser(name string) error {
shadow, err := LookupShadow(name)
if err != nil {
return err
}
if shadow.password[0] != _LOCK_CHAR {
shadow.password = string(_LOCK_CHAR) + shadow.password
return edit(name, shadow)
}
return nil
} | go | {
"resource": ""
} |
q172684 | NewGroup | validation | func NewGroup(name string, members ...string) *Group {
return &Group{
Name: name,
password: "",
GID: -1,
UserList: members,
}
} | go | {
"resource": ""
} |
q172685 | NewSystemGroup | validation | func NewSystemGroup(name string, members ...string) *Group {
return &Group{
Name: name,
password: "",
GID: -1,
UserList: members,
addSystemGroup: true,
}
} | go | {
"resource": ""
} |
q172686 | IsOfSystem | validation | func (g *Group) IsOfSystem() bool {
//loadConfig()
if g.GID > config.login.SYS_GID_MIN && g.GID < config.login.SYS_GID_MAX {
return true
}
return false
} | go | {
"resource": ""
} |
q172687 | parseGroup | validation | func parseGroup(row string) (*Group, error) {
fields := strings.Split(row, ":")
if len(fields) != 4 {
return nil, rowError{_GROUP_FILE, row}
}
gid, err := strconv.Atoi(fields[2])
if err != nil {
return nil, atoiError{_GROUP_FILE, row, "GID"}
}
return &Group{
Name: fields[0],
password: fields[1],
... | go | {
"resource": ""
} |
q172688 | lookUp | validation | func (*Group) lookUp(line string, f field, value interface{}) interface{} {
_field := f.(groupField)
allField := strings.Split(line, ":")
arrayField := make(map[int][]string)
intField := make(map[int]int)
arrayField[3] = strings.Split(allField[3], ",")
// Check integers
var err error
if intField[2], err = str... | go | {
"resource": ""
} |
q172689 | LookupGID | validation | func LookupGID(gid int) (*Group, error) {
entries, err := LookupInGroup(G_GID, gid, 1)
if err != nil {
return nil, err
}
return entries[0], err
} | go | {
"resource": ""
} |
q172690 | LookupGroup | validation | func LookupGroup(name string) (*Group, error) {
entries, err := LookupInGroup(G_NAME, name, 1)
if err != nil {
return nil, err
}
return entries[0], err
} | go | {
"resource": ""
} |
q172691 | Getgroups | validation | func Getgroups() []int {
user := GetUsername()
list := make([]int, 0)
// The user could have its own group.
if g, err := LookupGroup(user); err == nil {
list = append(list, g.GID)
}
groups, err := LookupInGroup(G_MEMBER, user, -1)
if err != nil {
if _, ok := err.(NoFoundError); !ok {
panic(err)
}
}
... | go | {
"resource": ""
} |
q172692 | GetgroupsName | validation | func GetgroupsName() []string {
user := GetUsername()
list := make([]string, 0)
// The user could have its own group.
if _, err := LookupGroup(user); err == nil {
list = append(list, user)
}
groups, err := LookupInGroup(G_MEMBER, user, -1)
if err != nil {
if _, ok := err.(NoFoundError); !ok {
panic(err)... | go | {
"resource": ""
} |
q172693 | AddGroup | validation | func AddGroup(name string, members ...string) (gid int, err error) {
s := NewGShadow(name, members...)
if err = s.Add(nil); err != nil {
return
}
return NewGroup(name, members...).Add()
} | go | {
"resource": ""
} |
q172694 | AddSystemGroup | validation | func AddSystemGroup(name string, members ...string) (gid int, err error) {
s := NewGShadow(name, members...)
if err = s.Add(nil); err != nil {
return
}
return NewSystemGroup(name, members...).Add()
} | go | {
"resource": ""
} |
q172695 | Add | validation | func (g *Group) Add() (gid int, err error) {
loadConfig()
group, err := LookupGroup(g.Name)
if err != nil {
if _, ok := err.(NoFoundError); !ok {
return 0, err
}
}
if group != nil {
return 0, ErrGroupExist
}
if g.Name == "" {
return 0, RequiredError("Name")
}
var db *dbfile
if g.GID < 0 {
db, ... | go | {
"resource": ""
} |
q172696 | DelGroup | validation | func DelGroup(name string) (err error) {
err = del(name, &Group{})
if err == nil {
err = del(name, &GShadow{})
}
return
} | go | {
"resource": ""
} |
q172697 | AddUsersToGroup | validation | func AddUsersToGroup(name string, members ...string) error {
if len(members) == 0 {
return fmt.Errorf("no members to add")
}
for i, v := range members {
if v == "" {
return EmptyMemberError(fmt.Sprintf("members[%s]", strconv.Itoa(i)))
}
}
// Group
gr, err := LookupGroup(name)
if err != nil {
return e... | go | {
"resource": ""
} |
q172698 | DelUsersInGroup | validation | func DelUsersInGroup(name string, members ...string) error {
if len(members) == 0 {
return ErrNoMembers
}
for i, v := range members {
if v == "" {
return EmptyMemberError(fmt.Sprintf("members[%s]", strconv.Itoa(i)))
}
}
// Group
gr, err := LookupGroup(name)
if err != nil {
return err
}
if err = _de... | go | {
"resource": ""
} |
q172699 | checkGroup | validation | func checkGroup(group []string, value string) bool {
for _, v := range group {
if v == value {
return true
}
}
return false
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.