id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c172600 | err := buf.ReadBytes('\n')
if err == io.EOF {
break
}
if bytes.Contains(line, b) {
return true, nil
}
}
return false, nil
} | |
c172601 | err := buf.ReadString('\n')
if err == io.EOF {
break
}
if strings.Contains(line, s) {
return true, nil
}
}
return false, nil
} | |
c172602 | := os.Getenv("PATH"); path == "" {
if err = os.Setenv("PATH", PATH); err != nil {
log.Print(err)
}
}*/
} | |
c172603 | }
} else {
if Log, err = syslog.NewLogger(syslog.LOG_NOTICE, log.Lshortfile); err != nil {
log.Fatal(err)
}
}
} | |
c172604 | := &dbfile{file: f, rd: bufio.NewReader(f)}
db.Lock()
return db, nil
} | |
c172605 | err
}
_FILES_BACKUPED[filename] = struct{}{}
}
}
return nil
} | |
c172606 | case Ebuild:
return new(ebuild)
case ZYpp:
return new(zypp)
}
panic("unreachable")
} | |
c172607 | {
panic("crypt: RegisterHash of unknown crypt function")
}
crypts[c] = f
cryptPrefixes[c] = prefix
} | |
c172608 | requested crypt function is unavailable")
} | |
c172609 | crypts[APR1]
} else {
toks := strings.SplitN(hashedKey, "$", 3)
prefix := "$" + toks[1] + "$"
panic("crypt: unknown cryp function from prefix: " + prefix)
}
if f != nil {
return f()
}
panic("crypt: requested cryp function is unavailable")
} | |
c172610 | string(s.key), string(s.value)
} | |
c172611 | os.Stderr
if err := c.Run(); err != nil {
return err
}
return nil
} | |
c172612 | append([]string{cmd}, args...)...)
} | |
c172613 | _, err = db.rd.ReadLine(); err != nil {
db.close()
return nil, 0, err
}
var minUid, maxUid int
if isSystem {
minUid, maxUid = config.login.SYS_UID_MIN, config.login.SYS_UID_MAX
} else {
minUid, maxUid = config.login.UID_MIN, config.login.UID_MAX
}
for {
line, _, err := db.rd.ReadLine()
if err == io.EOF {
break
}
u, err := parseUser(string(line))
if err != nil {
db.close()
return nil, 0, err
}
if u.UID >= minUid && u.UID <= maxUid {
uid = u.UID
}
}
uid++
if uid == maxUid {
return nil, 0, &IdRangeError{maxUid, isSystem, true}
}
return
} | |
c172614 | = config.login.SYS_GID_MIN, config.login.SYS_GID_MAX
} else {
minGid, maxGid = config.login.GID_MIN, config.login.GID_MAX
}
for {
line, _, err := db.rd.ReadLine()
if err == io.EOF {
break
}
gr, err := parseGroup(string(line))
if err != nil {
db.close()
return nil, 0, err
}
if gr.GID >= minGid && gr.GID <= maxGid {
gid = gr.GID
}
}
gid++
if gid == maxGid {
return nil, 0, &IdRangeError{maxGid, isSystem, false}
}
return
} | |
c172615 |
db.close()
return uid, err
} | |
c172616 |
db.close()
return gid, err
} | |
c172617 | db.close()
return uid, err
} | |
c172618 | db.close()
return gid, err
} | |
c172619 | _ENABLE_AGING,
Min: config.login.PASS_MIN_DAYS,
Max: config.login.PASS_MAX_DAYS,
Warn: config.login.PASS_WARN_AGE,
}
} | |
c172620 | }
warn, err := strconv.Atoi(fields[5])
if err != nil {
return nil, atoiError{_SHADOW_FILE, row, "Warn"}
}
// Optional fields
if fields[6] != "" {
if inactive, err = strconv.Atoi(fields[6]); err != nil {
return nil, atoiError{_SHADOW_FILE, row, "Inactive"}
}
}
if fields[7] != "" {
if expire, err = strconv.Atoi(fields[7]); err != nil {
return nil, atoiError{_SHADOW_FILE, row, "expire"}
}
}
if fields[8] != "" {
if flag, err = strconv.Atoi(fields[8]); err != nil {
return nil, atoiError{_SHADOW_FILE, row, "flag"}
}
}
return &Shadow{
fields[0],
fields[1],
changed,
min,
max,
warn,
inactive,
expire,
flag,
}, nil
} | |
c172621 | LookupInShadow(S_NAME, name, 1)
if err != nil {
return nil, err
}
return entries[0], err
} | |
c172622 |
return
}
defer func() {
e := db.close()
if e != nil && err == nil {
err = e
}
}()
if key != nil {
s.password, _ = config.crypter.Generate(key, nil)
if s.changed == _ENABLE_AGING {
s.setChange()
}
} else {
s.password = "*" // Password disabled.
}
_, err = db.file.WriteString(s.String())
return
} | |
c172623 | return err
}
dstFile, err := os.OpenFile(dest, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, srcInfo.Mode().Perm())
if err != nil {
return err
}
_, err = io.Copy(dstFile, srcFile)
err2 := dstFile.Close()
if err2 != nil && err == nil {
err = err2
}
return
} | |
c172624 | := file.Close()
if err2 != nil && err == nil {
err = err2
}
return
} | |
c172625 | := config.init(); err != nil {
panic(err)
}
})
} | |
c172626 | &edit{
_editDefault,
file,
bufio.NewReadWriter(bufio.NewReader(file), bufio.NewWriter(file)),
}, nil
} | |
c172627 | error {
return e.Append([]byte(s))
} | |
c172628 | {
break
}
for _, v := range allReSearch {
if v.Match(line) {
line = append(char, line...)
if !isNew {
isNew = true
}
break
}
}
if _, err = buf.Write(line); err != nil {
return err
}
}
if isNew {
return e.rewrite(buf.Bytes())
}
return nil
} | |
c172629 | e.CommentChar + "[[:space:]]*",
"",
}
}
return e.ReplaceAtLineN(allSearch, 1)
} | |
c172630 | err2 := e.Close()
if err != nil {
return err
}
return err2
} | |
c172631 | err2 := e.Close()
if err != nil {
return err
}
return err2
} | |
c172632 |
err2 := e.Close()
if err != nil {
return err
}
return err2
} | |
c172633 | if err != nil {
return err
}
err = e.genReplaceAtLine(r, -1)
err2 := e.Close()
if err != nil {
return err
}
return err2
} | |
c172634 | if err != nil {
return err
}
err = e.genReplaceAtLine(r, n)
err2 := e.Close()
if err != nil {
return err
}
return err2
} | |
c172635 | = getSettingsForUid(os.Getuid())
if err != nil {
panic(err)
}
} | |
c172636 | _settings.useKDE = true
}
for _, v := range shFamily {
if v == shell {
return _settings, nil
}
}
/*for _, v := range cshFamily {
if v == shell {
return _settings, nil
}
}*/
return settings{}, fmt.Errorf("shell unsopported: %s", shell)
} | |
c172637 |
if _, err = conf.Get(key); err != shconf.ErrKey {
panic("OPS")
}
}
return file.AppendString(filename, key+string(conf.Separator())+value)
} | |
c172638 |
if _, err = conf.Get(key); err != nil {
continue // TODO: log key already set.
}
buf.WriteString(key)
buf.Write(conf.Separator())
buf.WriteString(values[i])
buf.WriteByte('\n')
}
return file.Append(filename, buf.Bytes())
} | |
c172639 | if err != nil {
return err
}
if _SETTINGS.useKDE {
return _Set(_SETTINGS.kde, key, value)
}
return nil
} | |
c172640 | if err != nil {
return err
}
if _SETTINGS.useKDE {
return _MSet(_SETTINGS.kde, keys, values)
}
return nil
} | |
c172641 | err
}
if _settings.useKDE {
return _Set(_settings.kde, key, value)
}
return nil
} | |
c172642 | err
}
if _settings.useKDE {
return _MSet(_settings.kde, keys, values)
}
return nil
} | |
c172643 | _Set(_SETTINGS.global, key, value)
} | |
c172644 | _MSet(_SETTINGS.global, keys, values)
} | |
c172645 | if err != nil {
return err
}
return _Set(_settings.global, key, value)
} | |
c172646 | if err != nil {
return err
}
return _MSet(_settings.global, keys, values)
} | |
c172647 | username,
UserList: members,
}
} | |
c172648 | nil, rowError{_GSHADOW_FILE, row}
}
return &GShadow{
fields[0],
fields[1],
strings.Split(fields[2], ","),
strings.Split(fields[3], ","),
}, nil
} | |
c172649 | if GS_ADMIN&_field != 0 && checkGroup(arrayField[2], _value) {
isField = true
} else if GS_MEMBER&_field != 0 && checkGroup(arrayField[3], _value) {
isField = true
} else if GS_ALL&_field != 0 {
isField = true
}
if isField {
return &GShadow{
allField[0],
allField[1],
arrayField[2],
arrayField[3],
}
}
return nil
} | |
c172650 | LookupInGShadow(GS_NAME, name, 1)
if err != nil {
return nil, err
}
return entries[0], err
} | |
c172651 | {
e := db.close()
if e != nil && err == nil {
err = e
}
}()
if key != nil {
gs.password, _ = config.crypter.Generate(key, nil)
} else {
gs.password = "*" // Password disabled.
}
_, err = db.file.WriteString(gs.String())
return
} | |
c172652 |
Shell: config.useradd.SHELL,
UID: -1,
GID: gid,
}
} | |
c172653 | homeDir,
Shell: "/bin/false",
UID: -1,
GID: gid,
addSystemUser: true,
}
} | |
c172654 | config.login.SYS_UID_MAX {
return true
}
return false
} | |
c172655 | return nil, atoiError{_USER_FILE, row, "GID"}
}
return &User{
Name: fields[0],
password: fields[1],
UID: uid,
GID: gid,
Gecos: fields[4],
Dir: fields[5],
Shell: fields[6],
}, nil
} | |
c172656 | if U_DIR&_field != 0 && allField[5] == value.(string) {
isField = true
} else if U_SHELL&_field != 0 && allField[6] == value.(string) {
isField = true
} else if U_ALL&_field != 0 {
isField = true
}
if isField {
return &User{
Name: allField[0],
password: allField[1],
UID: intField[2],
GID: intField[3],
Gecos: allField[4],
Dir: allField[5],
Shell: allField[6],
}
}
return nil
} | |
c172657 | return nil, err
}
return entries[0], err
} | |
c172658 |
return nil, err
}
return entries[0], err
} | |
c172659 |
if err != nil {
panic(err)
}
return entry.Name
} | |
c172660 | {
name := os.Getenv(val)
if name != "" {
return name
}
}
return ""
} | |
c172661 |
if err = s.Add(nil); err != nil {
return
}
return NewUser(name, gid).Add()
} | |
c172662 | {
return
}
return NewSystemUser(name, homeDir, gid).Add()
} | |
c172663 | return 0, err
}
// Check if Id is unique.
_, err = LookupUID(u.UID)
if err == nil {
return 0, IdUsedError(u.UID)
} else if _, ok := err.(NoFoundError); !ok {
return 0, err
}
}
u.password = "x"
_, err = db.file.WriteString(u.String())
err2 := db.close()
if err2 != nil && err == nil {
err = err2
}
return
} | |
c172664 | err = del(name, &Shadow{})
}
return
} | |
c172665 | cfg.data[k] = v
if !gotSeparator {
cfg.separator = s.Separator()
gotSeparator = true
}
continue
} else if s.Err() != nil {
return nil, err
}
}
return cfg, nil
} | |
c172666 | fmt.Printf("\t%s: %s\n", k, v)
}
} | |
c172667 | found := c.data[key]; found {
return strconv.ParseBool(value)
}
return false, ErrKey
} | |
c172668 | found {
v, err := strconv.ParseInt(value, 10, 0)
return int(v), err
}
return 0, ErrKey
} | |
c172669 | c.data[key]; found {
v, err := strconv.ParseUint(value, 10, 0)
return uint(v), err
}
return 0, ErrKey
} | |
c172670 | found := c.data[key]; found {
return strconv.ParseFloat(value, 64)
}
return 0, ErrKey
} | |
c172671 |
if err := file.ReplaceAtLine(c.filename, replAt); err != nil {
return err
}
c.data[key] = value
return nil
} | |
c172672 | error) {
output, _, err = RunWithMatch(command)
return
} | |
c172673 | return nil, err
}
return &info{i}, nil
} | |
c172674 | if mode&modeWOwner == 0 {
return false
}
case X:
if mode&modeXOwner == 0 {
return false
}
}
}
return true
} | |
c172675 | if mode&modeWGroup == 0 {
return false
}
case X:
if mode&modeXGroup == 0 {
return false
}
}
}
return true
} | |
c172676 | if mode&modeWOthers == 0 {
return false
}
case X:
if mode&modeXOthers == 0 {
return false
}
}
}
return true
} | |
c172677 | return false, err
}
return i.OwnerHas(p...), nil
} | |
c172678 | err := parseShadow(string(line))
if err != nil {
log.Print(err)
continue
}
if shadow.password[0] == '$' {
return crypt.NewFromHash(shadow.password), nil
}
}
return nil, ErrShadowPasswd
} | |
c172679 | config.crypter.Generate(key, nil)
s.setChange()
} | |
c172680 | config.crypter.Generate(key, nil)
} | |
c172681 | err
}
shadow.Passwd(key)
return edit(user, shadow)
} | |
c172682 | err
}
gshadow.Passwd(key)
return edit(group, gshadow)
} | |
c172683 |
shadow.password = string(_LOCK_CHAR) + shadow.password
return edit(name, shadow)
}
return nil
} | |
c172684 |
password: "",
GID: -1,
UserList: members,
}
} | |
c172685 | -1,
UserList: members,
addSystemGroup: true,
}
} | |
c172686 | config.login.SYS_GID_MAX {
return true
}
return false
} | |
c172687 |
return &Group{
Name: fields[0],
password: fields[1],
GID: gid,
UserList: strings.Split(fields[3], ","),
}, nil
} | |
c172688 |
// Check fields
var isField bool
if G_NAME&_field != 0 && allField[0] == value.(string) {
isField = true
} else if G_PASSWD&_field != 0 && allField[1] == value.(string) {
isField = true
} else if G_GID&_field != 0 && intField[2] == value.(int) {
isField = true
} else if G_MEMBER&_field != 0 && checkGroup(arrayField[3], value.(string)) {
isField = true
} else if G_ALL&_field != 0 {
isField = true
}
if isField {
return &Group{
Name: allField[0],
password: allField[1],
GID: intField[2],
UserList: arrayField[3],
}
}
return nil
} | |
c172689 | return nil, err
}
return entries[0], err
} | |
c172690 |
return nil, err
}
return entries[0], err
} | |
c172691 | err != nil {
if _, ok := err.(NoFoundError); !ok {
panic(err)
}
}
for _, v := range groups {
list = append(list, v.GID)
}
return list
} | |
c172692 |
if err != nil {
if _, ok := err.(NoFoundError); !ok {
panic(err)
}
}
for _, v := range groups {
list = append(list, v.Name)
}
return list
} | |
c172693 | members...)
if err = s.Add(nil); err != nil {
return
}
return NewGroup(name, members...).Add()
} | |
c172694 | {
return
}
return NewSystemGroup(name, members...).Add()
} | |
c172695 | != nil {
db.close()
return 0, err
}
g.GID = gid
} else {
db, err = openDBFile(_GROUP_FILE, os.O_WRONLY|os.O_APPEND)
if err != nil {
return
}
// Check if Id is unique.
_, err = LookupGID(g.GID)
if err == nil {
return 0, IdUsedError(g.GID)
} else if _, ok := err.(NoFoundError); !ok {
return 0, err
}
}
g.password = "x"
_, err = db.file.WriteString(g.String())
err2 := db.close()
if err2 != nil && err == nil {
err = err2
}
return
} | |
c172696 | err = del(name, &GShadow{})
}
return
} | |
c172697 | := LookupGShadow(name)
if err != nil {
return err
}
if err = _addMembers(&sg.UserList, members...); err != nil {
return err
}
// Editing
if err = edit(name, gr); err != nil {
return err
}
if err = edit(name, sg); err != nil {
return err
}
return nil
} | |
c172698 | := LookupGShadow(name)
if err != nil {
return err
}
if err = _delMembers(&sg.UserList, members...); err != nil {
return err
}
// Editing
if err = edit(name, gr); err != nil {
return err
}
if err = edit(name, sg); err != nil {
return err
}
return nil
} | |
c172699 | v == value {
return true
}
}
return false
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.