func (d *Decoder) Decode(in *bufio.Reader, out *bytes.Buffer) (err error) {
for {
b, err := in.ReadByte()
if err != nil {
break
}
switch b {
case '=':
char := make([]byte, 2)
in.Read(char)
code, _ := strconv.ParseUint(string(char), 16, 8)
out.WriteByte(byte(code))
case '_':
err = out.WriteByte(' ')
case ' ':
return errors.New("Invalid char ` `")
case '?':
b, err = in.ReadByte()
if b == '=' {
return nil
}
return errors.New("Unexpected `?`")
default:
err = out.WriteByte(b)
}
}
return err
}
func readBulkData(conn *bufio.Reader, len int64) ([]byte, os.Error) {
buff := make([]byte, len)
_, e := io.ReadFull(conn, buff)
if e != nil {
return nil, NewErrorWithCause(SYSTEM_ERR, "Error while attempting read of bulkdata", e)
}
// fmt.Println ("Read ", n, " bytes. data: ", buff);
crb, e1 := conn.ReadByte()
if e1 != nil {
return nil, os.NewError("Error while attempting read of bulkdata terminal CR:" + e1.String())
}
if crb != CR_BYTE {
return nil, os.NewError("<BUG> bulkdata terminal was not CR as expected")
}
lfb, e2 := conn.ReadByte()
if e2 != nil {
return nil, os.NewError("Error while attempting read of bulkdata terminal LF:" + e2.String())
}
if lfb != LF_BYTE {
return nil, os.NewError("<BUG> bulkdata terminal was not LF as expected.")
}
return buff, nil
}
func newMessageReader(bufr *bufio.Reader) (*messageReader, error) {
if _, err := bufr.ReadBytes('"'); err != nil {
return nil, err
}
msg, err := bufr.ReadBytes('"')
if err != nil {
return nil, err
}
for {
b, err := bufr.Peek(1)
if err != nil {
return nil, err
}
if b[0] == ',' {
bufr.ReadByte()
break
}
if b[0] != ' ' {
break
}
bufr.ReadByte()
}
return &messageReader{
reader: bufr,
message: string(msg[:len(msg)-1]),
firstRead: true,
}, nil
}
func readArgument(r *bufio.Reader) ([]byte, error) {
line, err := r.ReadString('\n')
if err != nil {
return nil, malformed("$<argumentLength>", line)
}
var argSize int
if _, err := fmt.Sscanf(line, "$%d\r", &argSize); err != nil {
return nil, malformed("$<argumentSize>", line)
}
// I think int is safe here as the max length of request
// should be less then max int value?
data, err := ioutil.ReadAll(io.LimitReader(r, int64(argSize)))
if err != nil {
return nil, err
}
if len(data) != argSize {
return nil, malformedLength(argSize, len(data))
}
// Now check for trailing CR
if b, err := r.ReadByte(); err != nil || b != '\r' {
return nil, malformedMissingCRLF()
}
// And LF
if b, err := r.ReadByte(); err != nil || b != '\n' {
return nil, malformedMissingCRLF()
}
return data, nil
}
func readArray(r *bufio.Reader) (interface{}, error) {
_, err := r.ReadByte()
if err != nil {
return EMPTY_STRING, err
}
countAsStr, err := ReadLine(r)
if err != nil {
return EMPTY_STRING, err
}
arrLen, err := strconv.Atoi(countAsStr)
if err != nil {
return EMPTY_STRING, err
}
l := list.New()
for i := 0; i < arrLen; i++ {
val, err := readType(r)
if err != nil {
return EMPTY_STRING, err
}
l.PushBack(val)
}
return l, nil
}
func readByte(r *bufio.Reader) byte {
b, err := r.ReadByte()
if err != nil {
fmt.Println("error reading byte: ", err)
}
return b
}
func read_symbol(b *bufio.Reader) (goscm.SCMT, error) {
ret := ""
var c byte
var err error
for {
c, err = b.ReadByte()
if err != nil {
break
}
if c == ')' {
b.UnreadByte()
break
}
if c == ';' {
read_comment(b)
continue
}
if is_whitespace(c) {
break
}
ret = string(append([]byte(ret), c))
}
return goscm.NewSymbol(ret), err
}
func (state *scpUploadState) Protocol(in *bufio.Reader, out io.Writer) error {
for {
b, err := in.ReadByte()
if err != nil {
return err
}
switch b {
case 'T':
err := state.TimeProtocol(in, out)
if err != nil {
return err
}
case 'C':
return state.FileProtocol(in, out)
case 'E':
state.dir = filepath.Dir(state.dir)
fmt.Fprintf(out, scpOK)
return nil
case 'D':
return state.DirProtocol(in, out)
default:
fmt.Fprintf(out, scpEmptyError)
return fmt.Errorf("unexpected message: %c", b)
}
}
}
func peek(r *bufio.Reader) (c byte, e error) {
c, e = r.ReadByte()
if e != io.EOF {
r.UnreadByte()
}
return
}
func newLexer(in *bufio.Reader) *lexer {
l := &lexer{src: in, line: 1}
if b, err := in.ReadByte(); err == nil {
l.current = b
}
return l
}
func readArgument(reader *bufio.Reader) ([]byte, error) {
line, err := reader.ReadString('\n')
if err != nil {
return nil, Malformed("$<ArgumentLength>", line)
}
var argLength int
if _, err := fmt.Sscanf(line, "$%d\r", &argLength); err != nil {
return nil, Malformed("$<ArgumentLength>", line)
}
data, err := ioutil.ReadAll(io.LimitReader(reader, int64(argLength)))
if err != nil {
return nil, err
}
if len(data) != argLength {
return nil, MalformedLength(argLength, len(data))
}
if b, err := reader.ReadByte(); err != nil || b != '\r' {
return nil, MalformedMissingCRLF()
}
if b, err := reader.ReadByte(); err != nil || b != '\n' {
return nil, MalformedMissingCRLF()
}
return data, nil
}
// Reads a single word from a file, assuming space + tab + EOL to be word boundaries
func ReadWord(fin *bufio.Reader) (word string, err error) {
var a int = 0
var ch byte
var buf bytes.Buffer
for {
ch, err = fin.ReadByte()
if err == io.EOF {
break
}
if ch == 13 {
continue
}
if (ch == ' ') || (ch == '\t') || (ch == '\n') {
if a > 0 {
if ch == '\n' {
fin.UnreadByte()
}
break
}
if ch == '\n' {
word = "</s>"
return
} else {
continue
}
}
buf.WriteByte(ch)
a++
}
if a >= MAX_STRING { // Truncate too long words
buf.Truncate(MAX_STRING)
}
word = buf.String()
return
}
func (g *CGIRefVar) RefByte(strand int, ref_stream *bufio.Reader) (byte, error) {
if strand <= 0 {
ref_bp, e := ref_stream.ReadByte()
if e != nil {
return ref_bp, e
}
for (ref_bp == '\n') || (ref_bp == ' ') || (ref_bp == '\r') || (ref_bp == '\t') {
ref_bp, e = ref_stream.ReadByte()
if e != nil {
return ref_bp, e
}
}
g.RefBuf = append(g.RefBuf, ref_bp)
g.RefPos[0]++
return ref_bp, e
}
if g.RefPos[1] >= len(g.RefBuf) {
panic(fmt.Sprintf("g.RefPos[1] %d >= len(g.RefBuf) %d (RefPos:%v, RefBuf:%s, line %d '%s')", g.RefPos[1], len(g.RefBuf), g.RefPos, g.RefBuf, g.LCounter, g.CGIVarLine))
}
ref_bp := g.RefBuf[g.RefPos[1]]
g.RefPos[1]++
return ref_bp, nil
}
func Decode(input *bufio.Reader) (_ string, err error) {
buf := bytes.NewBufferString("")
for {
b, err := input.ReadByte()
if err != nil {
break
}
if b != '=' {
err = buf.WriteByte(b)
} else {
input.UnreadByte()
charset, err := readCharset(input)
if err != nil {
return "", err
}
encoding, err := readEncoding(input)
if err != nil {
return "", err
}
(&Decoder{encoding, charset}).Decode(input, buf)
}
}
if err == io.EOF {
return buf.String(), nil
}
return buf.String(), err
}
func groupLs(r *bufio.Reader, w *bufio.Writer, args []string, thisUser *utils.User) (err error) {
if len(args) != 2 {
fmt.Println("Wrong number of arguments for call to group-ls:")
fmt.Println("Format should be: group-ls GID")
return nil
}
err = w.WriteByte(23)
w.Flush()
if err != nil {
return err
}
// send the group id
w.WriteString(args[1] + "\n")
w.Flush()
// get success (1) or fail (2)
success, _ := r.ReadByte()
if success != 1 {
fmt.Println("The group does not exist")
return err
}
// get uuids of the group
result, _ := r.ReadString('\n')
result = strings.TrimSuffix(strings.TrimSpace(result), ",")
fmt.Println("Members of Group " + args[1] + ": " + result)
return err
}
// ReadWhitespace will read from the reader until no whitespace is encountered
func ReadWhitespace(r *bufio.Reader) {
c, e := peek(r)
for e != io.EOF && isWhitespace(c) {
r.ReadByte()
c, e = peek(r)
}
}
// decodeBinary decodes BSON Binary element.
func decodeBinary(rd *bufio.Reader) (string, Binary, error) {
// name
name, err := readCstring(rd)
if err != nil {
return "", nil, err
}
// value
dataLen, err := readInt32(rd)
if err != nil {
return "", nil, err
}
// discard subtype
_, err = rd.ReadByte()
if err != nil {
return "", nil, err
}
b := make([]byte, dataLen)
_, err = io.ReadFull(rd, b)
if err != nil {
return "", nil, err
}
return name, Binary(b), nil
}
func parseIndexEntry(r *bufio.Reader) (entry *IndexEntry, err error) {
var binEntry indexEntry
err = binary.Read(r, ord, &binEntry)
if err != nil {
return nil, err
}
// TODO: what if it is corrupted and too long?
name, e := r.ReadBytes(token.NUL)
if e != nil {
return nil, e
}
name = util.TrimLastByte(name) // get rid of NUL
// don't ask me how I figured this out after
// a 14 hour workday
leftOver := 7 - (len(name)+6)%8
for j := 0; j < leftOver; j++ {
// TODO: read the bytes at once somehow
if _, err = r.ReadByte(); err != nil {
return nil, err
}
}
// record the entry
return toIndexEntry(&binEntry, string(name)), nil
}
func HandshakeSample(c net.Conn, br *bufio.Reader, bw *bufio.Writer, timeout time.Duration) (err error) {
defer func() {
if r := recover(); r != nil {
err = r.(error)
}
}()
// Send C0+C1
err = bw.WriteByte(0x03)
c1 := CreateRandomBlock(RTMP_SIG_SIZE)
for i := 0; i < 8; i++ {
c1[i] = 0
}
bw.Write(c1)
err = bw.Flush()
CheckError(err, "Handshake() Flush C0+C1")
// Read S0+S1+S2
s0, err := br.ReadByte()
CheckError(err, "Handshake() Read S0")
if s0 != 0x03 {
return errors.New(fmt.Sprintf("Handshake() Got S0: %x", s0))
}
s1 := make([]byte, RTMP_SIG_SIZE)
_, err = io.ReadAtLeast(br, s1, RTMP_SIG_SIZE)
CheckError(err, "Handshake() Read S1")
bw.Write(s1)
err = bw.Flush()
CheckError(err, "Handshake() Flush C2")
_, err = io.ReadAtLeast(br, s1, RTMP_SIG_SIZE)
CheckError(err, "Handshake() Read S2")
return
}
func preprocess(buf []byte, r *bufio.Reader) (int, error) {
i := 0
for c, n, err := r.ReadRune(); err == nil; c, n, err = r.ReadRune() {
if i+n > len(buf) {
// We don't have room so unread the rune and return.
r.UnreadRune()
return i, err
}
switch c {
case '\x00':
if len(buf)-1 < i+len(unknownRune) {
copy(buf[i:len(unknownRune)], unknownRune)
} else {
// We don't have room so unread the rune and
// return.
r.UnreadRune()
return i + n, err
}
case '\r':
buf[i] = '\n'
nxt, err := r.Peek(1)
if err == nil && len(nxt) == 1 && nxt[0] == '\n' {
r.ReadByte()
}
case '\f':
buf[i] = '\n'
default:
copy(buf[i:i+n], []byte(string(c)))
}
i += n
}
return i, nil
}
func readBulkStr(r *bufio.Reader) (Resp, error) {
b, err := r.ReadBytes(delimEnd)
if err != nil {
return Resp{}, err
}
size, err := strconv.ParseInt(string(b[1:len(b)-2]), 10, 64)
if err != nil {
return Resp{}, errParse
}
if size < 0 {
return Resp{typ: Nil}, nil
}
total := make([]byte, size)
b2 := total
var n int
for len(b2) > 0 {
n, err = r.Read(b2)
if err != nil {
return Resp{}, err
}
b2 = b2[n:]
}
// There's a hanging \r\n there, gotta read past it
trail := make([]byte, 2)
for i := 0; i < 2; i++ {
c, err := r.ReadByte()
if err != nil {
return Resp{}, err
}
trail[i] = c
}
return Resp{typ: BulkStr, val: total}, nil
}
func readHexInt(r *bufio.Reader) (int, error) {
n := 0
i := 0
var k int
for {
c, err := r.ReadByte()
if err != nil {
if err == io.EOF && i > 0 {
return n, nil
}
return -1, err
}
k = hexbyte2int(c)
if k < 0 {
if i == 0 {
return -1, errEmptyHexNum
}
r.UnreadByte()
return n, nil
}
if i >= maxHexIntChars {
return -1, errTooLargeHexNum
}
n = (n << 4) | k
i++
}
}
func readMultiBulk(br *bufio.Reader) ([][]byte, error) {
count, err := readInt(br)
switch {
case err != nil:
return nil, err
case count < 0:
return nil, PROTOCOL_ERROR
}
data := make([][]byte, 0, count)
for count > 0 {
f, err := br.ReadByte()
var b []byte
switch f {
case '$':
b, err = readBulk(br)
if err != nil {
return nil, err
}
case ':':
// coerce an integer into mere bytes
b, err = readLine(br)
if err != nil {
return nil, err
}
default:
return nil, PROTOCOL_ERROR
}
data = append(data, b)
count--
}
return data, nil
}
func (binaryNode *BinaryNode) unserialize(reader *bufio.Reader) (err error) {
for {
var what uint8
if what, err = reader.ReadByte(); err != nil {
// Most likely an EOF and we don't care.
return nil
}
switch what {
case NodeStart:
var newNode BinaryNode
if err = newNode.unserialize(reader); err != nil {
return
}
binaryNode.children = append(binaryNode.children, newNode)
case NodeEnd:
return nil
case EscapeChar:
var b uint8
if b, err = reader.ReadByte(); err != nil {
return
}
binaryNode.data = append(binaryNode.data, b)
default:
binaryNode.data = append(binaryNode.data, what)
}
}
return nil
}
func readBulkString(r *bufio.Reader) (interface{}, error) {
_, err := r.ReadByte()
if err != nil {
return EMPTY_STRING, err
}
countAsStr, err := ReadLine(r)
if err != nil {
return EMPTY_STRING, err
}
count, err := strconv.Atoi(countAsStr)
if err != nil {
return EMPTY_STRING, err
}
if count == -1 {
return countAsStr, nil
}
line, err := ReadLine(r)
if err != nil {
return EMPTY_STRING, err
}
if len(line) != count {
return EMPTY_STRING, errors.New("Expected " + countAsStr + " characters in string and got " + line)
}
return line, nil
}
func _StringDecode(in *bufio.Reader, stringkeys bool) interface{} {
assertNextByte(in, BYTE_STRING)
str := bytes.Buffer{}
escape := false
for {
character, err := in.ReadByte()
if err == io.EOF {
panic("Expected unescaped \\1 to end string! (Got EOF)")
} else if escape {
// handle escape condition for next character
if character == 0x3 {
str.WriteByte(0x0)
} else {
str.WriteByte(character)
}
} else if character == 0x2 {
escape = true
} else if character == BYTE_END {
return str.String()
} else {
str.WriteByte(character)
}
}
return str.String()
}
func ReadTillEOL(reader *bufio.Reader, buf []byte) int {
i := 0
for {
ch, err := reader.ReadByte()
if err != nil {
return -1
}
if i >= len(buf) {
return i
}
if ch == '\r' {
ch, err := reader.ReadByte()
if err != nil {
return -1
}
if ch == '\n' {
return i
} else {
buf[i] = '\r'
buf[i+1] = ch
i += 1
}
} else {
buf[i] = ch
}
i += 1
}
return i
}
func deleteGroup(r *bufio.Reader, w *bufio.Writer, args []string, thisUser *utils.User) (err error) {
if len(args) < 2 {
fmt.Println("Not enough arguments for call to group-remove:")
fmt.Println("Format should be: delete-group GID")
return nil
}
err = w.WriteByte(24)
w.Flush()
if err != nil {
return err
}
w.WriteString(args[1] + "\n")
w.Flush()
// get success (1) or fail (2)
success, _ := r.ReadByte()
if success != 1 {
fmt.Println("You cannot remove this group. Does it exist/are you the owner?")
return err
}
fmt.Println("Removed: " + args[1])
return err
}
func readHexInt(r *bufio.Reader) (int, error) {
n := 0
i := 0
var k int
for {
c, err := r.ReadByte()
if err != nil {
if err == io.EOF && i > 0 {
return n, nil
}
return -1, err
}
k = hexbyte2int(c)
if k < 0 {
if i == 0 {
return -1, fmt.Errorf("cannot read hex num from empty string")
}
r.UnreadByte()
return n, nil
}
if i >= maxHexIntChars {
return -1, fmt.Errorf("cannot read hex num with more than %d digits", maxHexIntChars)
}
n = (n << 4) | k
i++
}
}
func readLine(r *bufio.Reader) (fname string, types []string, data string, err error) {
var line []byte
for len(line) == 0 {
var short bool
line, short, err = r.ReadLine()
if short {
err = fmt.Errorf("line too long")
return
}
if err != nil {
return
}
line = bytes.TrimSpace(line)
}
b, err := r.ReadByte()
if err == io.EOF || b != ' ' {
r.UnreadByte()
return parseLine(string(line))
}
for b == ' ' && err != io.EOF {
r.UnreadByte()
stub, short, err := r.ReadLine()
if !short {
err = fmt.Errorf("line too long")
return fname, types, data, err
}
line = append(line, bytes.TrimSpace(stub)...)
b, err = r.ReadByte()
}
r.UnreadByte()
return parseLine(string(line))
}