Ejemplo n.º 1
0
func readUntilCrLf(con *net.TCPConn) (line []byte, err os.Error) {

	buf := make([]byte, 1)
	var data []byte
	crSeen := false

	for {
		_, err := con.Read(buf)
		if err != nil {
			if err == os.EOF {
				break
			} else {
				return nil, err
			}
		}
		if crSeen {
			if buf[0] == 10 {
				break
			} else {
				crSeen = false
				data = bytes.Add(data, buf)
			}
		} else {
			if buf[0] == 13 {
				crSeen = true
			} else {
				data = bytes.Add(data, buf)
			}
		}
	}

	return data, nil
}
Ejemplo n.º 2
0
// Extract regular text from the beginning of the pattern.
// That text can be used by doExecute to speed up matching.
func (re *Regexp) setPrefix() {
	var b []byte
	var utf = make([]byte, utf8.UTFMax)
	// First instruction is start; skip that.
	i := re.inst.At(0).(instr).next().index()
Loop:
	for i < re.inst.Len() {
		inst := re.inst.At(i).(instr)
		// stop if this is not a char
		if inst.kind() != _CHAR {
			break
		}
		// stop if this char can be followed by a match for an empty string,
		// which includes closures, ^, and $.
		switch re.inst.At(inst.next().index()).(instr).kind() {
		case _BOT, _EOT, _ALT:
			break Loop
		}
		n := utf8.EncodeRune(inst.(*_Char).char, utf)
		b = bytes.Add(b, utf[0:n])
		i = inst.next().index()
	}
	// point prefixStart instruction to first non-CHAR after prefix
	re.prefixStart = re.inst.At(i).(instr)
	re.prefixBytes = b
	re.prefix = string(b)
}
Ejemplo n.º 3
0
// UnmarshalJSON sets *m to a copy of data.
func (m *RawMessage) UnmarshalJSON(data []byte) os.Error {
	if m == nil {
		return os.NewError("json.RawMessage: UnmarshalJSON on nil pointer")
	}
	*m = bytes.Add((*m)[0:0], data)
	return nil
}
Ejemplo n.º 4
0
// readHandshake reads the next handshake message from
// the record layer.
// c.in.Mutex < L; c.out.Mutex < L.
func (c *Conn) readHandshake() (interface{}, os.Error) {
	for c.hand.Len() < 4 {
		if c.err != nil {
			return nil, c.err
		}
		c.readRecord(recordTypeHandshake)
	}

	data := c.hand.Bytes()
	n := int(data[1])<<16 | int(data[2])<<8 | int(data[3])
	if n > maxHandshake {
		c.sendAlert(alertInternalError)
		return nil, c.err
	}
	for c.hand.Len() < 4+n {
		if c.err != nil {
			return nil, c.err
		}
		c.readRecord(recordTypeHandshake)
	}
	data = c.hand.Next(4 + n)
	var m handshakeMessage
	switch data[0] {
	case typeClientHello:
		m = new(clientHelloMsg)
	case typeServerHello:
		m = new(serverHelloMsg)
	case typeCertificate:
		m = new(certificateMsg)
	case typeCertificateRequest:
		m = new(certificateRequestMsg)
	case typeCertificateStatus:
		m = new(certificateStatusMsg)
	case typeServerHelloDone:
		m = new(serverHelloDoneMsg)
	case typeClientKeyExchange:
		m = new(clientKeyExchangeMsg)
	case typeCertificateVerify:
		m = new(certificateVerifyMsg)
	case typeNextProtocol:
		m = new(nextProtoMsg)
	case typeFinished:
		m = new(finishedMsg)
	default:
		c.sendAlert(alertUnexpectedMessage)
		return nil, alertUnexpectedMessage
	}

	// The handshake message unmarshallers
	// expect to be able to keep references to data,
	// so pass in a fresh copy that won't be overwritten.
	data = bytes.Add(nil, data)

	if !m.unmarshal(data) {
		c.sendAlert(alertUnexpectedMessage)
		return nil, alertUnexpectedMessage
	}
	return m, nil
}
Ejemplo n.º 5
0
func EncodeSOA(soa SOArecord) []byte {
	var (
		result []byte
		temp32 []byte
	)
	mname := Encode(soa.Mname)
	length := len(mname)
	rname := Encode(soa.Rname)
	length = length + len(rname)
	length = length + (5 * 4) // Five 32-bits counter at the end
	/* "It's probably cleaner to write to a bytes.Buffer than to
	repeatedly call bytes.Add." Russ Cox, go-nuts ML */
	result = bytes.Add(result, mname)
	result = bytes.Add(result, rname)
	temp32 = make([]byte, 4)
	binary.BigEndian.PutUint32(temp32, soa.Serial)
	result = bytes.Add(result, temp32)
	binary.BigEndian.PutUint32(temp32, soa.Refresh)
	result = bytes.Add(result, temp32)
	binary.BigEndian.PutUint32(temp32, soa.Retry)
	result = bytes.Add(result, temp32)
	binary.BigEndian.PutUint32(temp32, soa.Expire)
	result = bytes.Add(result, temp32)
	binary.BigEndian.PutUint32(temp32, soa.Minimum)
	result = bytes.Add(result, temp32)
	return result[0:length]
}
Ejemplo n.º 6
0
// To use with messages that receive a response from database
// 'opQuery', 'opGetMore'.
func (self *Connection) sendMessageToReply(m message, reqID int32) os.Error {
	body := m.Bytes()
	h := header(msgHeader{int32(len(body) + _HEADER_SIZE), reqID, 0, m.OpCode()})

	msg := bytes.Add(h, body)
	_, err := self.conn.Write(msg)

	return err
}
Ejemplo n.º 7
0
func Decode(b []byte) []byte {
	r := make([]byte, len(b)*2)[0:0]
	for {
		if b[0] != 128 {
			break
		}
		if b[1] == 3 {
			break
		}
		l := int(b[2]) + (int(b[3]) << 8) + (int(b[4]) << 16) + 6
		if b[1] == 1 {
			r = bytes.Add(r, b[6:l])
		} else {
			r = bytes.Add(r, hex.Encode(b[6:l]))
		}
		b = b[l:]
	}
	return r
}
Ejemplo n.º 8
0
func (c *Connection) writeMessage(m message) os.Error {
	body := m.Bytes()
	hb := header(int32(len(body)+16), m.RequestID(), 0, m.OpCode())
	msg := bytes.Add(hb, body)

	_, err := c.conn.Write(msg)

	last_req = m.RequestID()
	return err
}
Ejemplo n.º 9
0
func (self *_Object) Bytes() []byte {
	buf := bytes.NewBuffer([]byte{})
	for k, v := range self.value {
		buf.WriteByte(byte(v.Kind()))
		buf.WriteString(k)
		buf.WriteByte(0)
		buf.Write(v.Bytes())
	}
	buf.WriteByte(0)

	l := buf.Len() + 4
	w32 := make([]byte, _WORD32)
	pack.PutUint32(w32, uint32(l))
	return bytes.Add(w32, buf.Bytes())
}
Ejemplo n.º 10
0
func (self *_Array) Bytes() []byte {
	buf := bytes.NewBuffer([]byte{})

	for i := 0; i < self.value.Len(); i++ {
		v := self.value.At(i).(BSON)
		buf.WriteByte(byte(v.Kind()))
		buf.WriteString(strconv.Itoa(i))
		buf.WriteByte(0)
		buf.Write(v.Bytes())
	}
	buf.WriteByte(0)

	l := buf.Len() + 4
	w32 := make([]byte, _WORD32)
	pack.PutUint32(w32, uint32(l))
	return bytes.Add(w32, buf.Bytes())
}
Ejemplo n.º 11
0
func Repeat(alu []byte, n int) {
	buf := bytes.Add(alu, alu)
	off := 0
	for n > 0 {
		m := n
		if m > Line {
			m = Line
		}
		buf1 := out.NextWrite(m + 1)
		copy(buf1, buf[off:])
		buf1[m] = '\n'
		if off += m; off >= len(alu) {
			off -= len(alu)
		}
		n -= m
	}
}
Ejemplo n.º 12
0
func (self *Client) simpleQuery(command int, version int, size int, body []byte) ([]byte, os.Error) {
	conn, err := self.connect()
	if err != nil {
		return nil, err
	}

	header := make([]byte, 8+len(body))
	binary.BigEndian.PutUint16(header[0:2], uint16(command))
	binary.BigEndian.PutUint16(header[2:4], uint16(version))
	binary.BigEndian.PutUint32(header[4:8], uint32(size))

	request := bytes.Add(header, body)

	_, err = conn.Write(request)
	if err != nil {
		return nil, err
	}

	return self.getResponse(conn)
}
Ejemplo n.º 13
0
Archivo: gut.go Proyecto: beoran/fungo
// ReadAll takes an os.File as it's argument and reads in all of it until 
// it signals to stop with an EOF in 
func ReadAll(file * os.File) ([]byte, os.Error) { 
  const BUFSIZE = 1024
  result    := make([]byte, 0)
  buf       := make([]byte, BUFSIZE)
  var sub []byte 
  for { // ever     
    count, err2 := file.Read(buf)
    sub          = buf[0:count]
    // get right slice to append to result
    // append bytes to result
    if count > 0 { 
      result = bytes.Add(result, sub)
    }
    // if EOF, return the result. 
    if err2 == os.EOF { return result, nil }
    // on any other error return nil 
    if err2 != nil    { return nil   , err2 }    
  }
  // should not get here  
  return nil, os.NewError("Can't happen?!");
}
Ejemplo n.º 14
0
func TestRecords(t *testing.T) {
	for i, test := range recordsTests {
		buf := bytes.NewBuffer(test.raw)
		content, reqId, kind, err := readRecord(buf)
		if err != nil {
			t.Errorf("%d error reading record: %s", i, err.String())
			goto write
		}
		for buf.Len() > 0 {
			moreContent, _, _, err := readRecord(buf)
			if err != nil {
				t.Errorf("%d error reading additional record: %s", i, err.String())
				goto write
			}
			content = bytes.Add(content, moreContent)
		}
		if kind != test.kind {
			t.Errorf("%d got kind %d expected %d", i, kind, test.kind)
		}
		if reqId != test.reqId {
			t.Errorf("%d got request ID %d expected %d", i, kind, test.kind)
		}
		if !bytes.Equal(content, test.content) {
			t.Errorf("%d read wrong content", i)
		}
	write:
		buf.Reset()
		c := &lockReadWriteCloser{ReadWriteCloser: &nilCloser{buf}}
		err = writeRecord(c, test.kind, test.reqId, test.content)
		if err != nil {
			t.Errorf("%d error writing record: %s", i, err.String())
			continue
		}
		if !bytes.Equal(buf.Bytes(), test.raw) {
			t.Errorf("%d wrote wrong content", i)
		}
	}
}
Ejemplo n.º 15
0
func TestNextValueBig(t *testing.T) {
	var scan scanner
	item, rest, err := nextValue(jsonBig, &scan)
	if err != nil {
		t.Fatalf("nextValue: ", err)
	}
	if len(item) != len(jsonBig) || &item[0] != &jsonBig[0] {
		t.Errorf("invalid item: %d %d", len(item), len(jsonBig))
	}
	if len(rest) != 0 {
		t.Errorf("invalid rest: %d", len(rest))
	}

	item, rest, err = nextValue(bytes.Add(jsonBig, []byte("HELLO WORLD")), &scan)
	if err != nil {
		t.Fatalf("nextValue extra: ", err)
	}
	if len(item) != len(jsonBig) {
		t.Errorf("invalid item: %d %d", len(item), len(jsonBig))
	}
	if string(rest) != "HELLO WORLD" {
		t.Errorf("invalid rest: %d", len(rest))
	}
}
Ejemplo n.º 16
0
// ReadContinuedLineBytes is like ReadContinuedLine but
// returns a []byte instead of a string.
func (r *Reader) ReadContinuedLineBytes() ([]byte, os.Error) {
	// Read the first line.
	line, err := r.ReadLineBytes()
	if err != nil {
		return line, err
	}
	if len(line) == 0 { // blank line - no continuation
		return line, nil
	}
	line = trim(line)

	// Look for a continuation line.
	c, err := r.R.ReadByte()
	if err != nil {
		// Delay err until we read the byte next time.
		return line, nil
	}
	if c != ' ' && c != '\t' {
		// Not a continuation.
		r.R.UnreadByte()
		return line, nil
	}

	// Read continuation lines.
	for {
		// Consume leading spaces; one already gone.
		for {
			c, err = r.R.ReadByte()
			if err != nil {
				break
			}
			if c != ' ' && c != '\t' {
				r.R.UnreadByte()
				break
			}
		}
		var cont []byte
		cont, err = r.ReadLineBytes()
		cont = trim(cont)
		line = bytes.Add(line, space)
		line = bytes.Add(line, cont)
		if err != nil {
			break
		}

		// Check for leading space on next line.
		if c, err = r.R.ReadByte(); err != nil {
			break
		}
		if c != ' ' && c != '\t' {
			r.R.UnreadByte()
			break
		}
	}

	// Delay error until next call.
	if len(line) > 0 {
		err = nil
	}
	return line, err
}
Ejemplo n.º 17
0
func TestEncodeFloat64(t *testing.T) {
	expected := bytes.Add([]byte{MAGIC, FLOAT}, strings.Bytes(fmt.Sprintf("%.20e", float64(1.2e3))))
	testEncode(t, "Encoding float64 failed", 1.2e3, expected)
}
Ejemplo n.º 18
0
func TestEncodeString(t *testing.T) {
	expected := bytes.Add([]byte{MAGIC, BIN, 0, 0, 0, 3}, strings.Bytes("foo"))
	testEncode(t, "Encoding string failed", "foo", expected)
}
Ejemplo n.º 19
0
// Unmarshal a single XML element into val.
func (p *Parser) unmarshal(val reflect.Value, start *StartElement) os.Error {
	// Find start element if we need it.
	if start == nil {
		for {
			tok, err := p.Token()
			if err != nil {
				return err
			}
			if t, ok := tok.(StartElement); ok {
				start = &t
				break
			}
		}
	}

	if pv, ok := val.(*reflect.PtrValue); ok {
		if pv.Get() == 0 {
			zv := reflect.MakeZero(pv.Type().(*reflect.PtrType).Elem())
			pv.PointTo(zv)
			val = zv
		} else {
			val = pv.Elem()
		}
	}

	var (
		data        []byte
		saveData    reflect.Value
		comment     []byte
		saveComment reflect.Value
		sv          *reflect.StructValue
		styp        *reflect.StructType
	)
	switch v := val.(type) {
	default:
		return os.ErrorString("unknown type " + v.Type().String())

	case *reflect.BoolValue:
		v.Set(true)

	case *reflect.SliceValue:
		typ := v.Type().(*reflect.SliceType)
		if _, ok := typ.Elem().(*reflect.Uint8Type); ok {
			// []byte
			saveData = v
			break
		}

		// Slice of element values.
		// Grow slice.
		n := v.Len()
		if n >= v.Cap() {
			ncap := 2 * n
			if ncap < 4 {
				ncap = 4
			}
			new := reflect.MakeSlice(typ, n, ncap)
			reflect.ArrayCopy(new, v)
			v.Set(new)
		}
		v.SetLen(n + 1)

		// Recur to read element into slice.
		if err := p.unmarshal(v.Elem(n), start); err != nil {
			v.SetLen(n)
			return err
		}
		return nil

	case *reflect.StringValue,
		*reflect.IntValue, *reflect.UintValue, *reflect.UintptrValue,
		*reflect.Int8Value, *reflect.Int16Value, *reflect.Int32Value, *reflect.Int64Value,
		*reflect.Uint8Value, *reflect.Uint16Value, *reflect.Uint32Value, *reflect.Uint64Value,
		*reflect.FloatValue, *reflect.Float32Value, *reflect.Float64Value:
		saveData = v

	case *reflect.StructValue:
		if _, ok := v.Interface().(Name); ok {
			v.Set(reflect.NewValue(start.Name).(*reflect.StructValue))
			break
		}

		sv = v
		typ := sv.Type().(*reflect.StructType)
		styp = typ
		// Assign name.
		if f, ok := typ.FieldByName("XMLName"); ok {
			// Validate element name.
			if f.Tag != "" {
				tag := f.Tag
				ns := ""
				i := strings.LastIndex(tag, " ")
				if i >= 0 {
					ns, tag = tag[0:i], tag[i+1:]
				}
				if tag != start.Name.Local {
					return UnmarshalError("expected element type <" + tag + "> but have <" + start.Name.Local + ">")
				}
				if ns != "" && ns != start.Name.Space {
					e := "expected element <" + tag + "> in name space " + ns + " but have "
					if start.Name.Space == "" {
						e += "no name space"
					} else {
						e += start.Name.Space
					}
					return UnmarshalError(e)
				}
			}

			// Save
			v := sv.FieldByIndex(f.Index)
			if _, ok := v.Interface().(Name); !ok {
				return UnmarshalError(sv.Type().String() + " field XMLName does not have type xml.Name")
			}
			v.(*reflect.StructValue).Set(reflect.NewValue(start.Name).(*reflect.StructValue))
		}

		// Assign attributes.
		// Also, determine whether we need to save character data or comments.
		for i, n := 0, typ.NumField(); i < n; i++ {
			f := typ.Field(i)
			switch f.Tag {
			case "attr":
				strv, ok := sv.FieldByIndex(f.Index).(*reflect.StringValue)
				if !ok {
					return UnmarshalError(sv.Type().String() + " field " + f.Name + " has attr tag but is not type string")
				}
				// Look for attribute.
				val := ""
				k := strings.ToLower(f.Name)
				for _, a := range start.Attr {
					if fieldName(a.Name.Local) == k {
						val = a.Value
						break
					}
				}
				strv.Set(val)

			case "comment":
				if saveComment == nil {
					saveComment = sv.FieldByIndex(f.Index)
				}

			case "chardata":
				if saveData == nil {
					saveData = sv.FieldByIndex(f.Index)
				}
			}
		}
	}

	// Find end element.
	// Process sub-elements along the way.
Loop:
	for {
		tok, err := p.Token()
		if err != nil {
			return err
		}
		switch t := tok.(type) {
		case StartElement:
			// Sub-element.
			// Look up by tag name.
			// If that fails, fall back to mop-up field named "Any".
			if sv != nil {
				k := fieldName(t.Name.Local)
				any := -1
				for i, n := 0, styp.NumField(); i < n; i++ {
					f := styp.Field(i)
					if strings.ToLower(f.Name) == k {
						if err := p.unmarshal(sv.FieldByIndex(f.Index), &t); err != nil {
							return err
						}
						continue Loop
					}
					if any < 0 && f.Name == "Any" {
						any = i
					}
				}
				if any >= 0 {
					if err := p.unmarshal(sv.FieldByIndex(styp.Field(any).Index), &t); err != nil {
						return err
					}
					continue Loop
				}
			}
			// Not saving sub-element but still have to skip over it.
			if err := p.Skip(); err != nil {
				return err
			}

		case EndElement:
			break Loop

		case CharData:
			if saveData != nil {
				data = bytes.Add(data, t)
			}

		case Comment:
			if saveComment != nil {
				comment = bytes.Add(comment, t)
			}
		}
	}

	var err os.Error
	// Helper functions for integer and unsigned integer conversions
	var itmp int64
	getInt64 := func() bool {
		itmp, err = strconv.Atoi64(string(data))
		// TODO: should check sizes
		return err == nil
	}
	var utmp uint64
	getUint64 := func() bool {
		utmp, err = strconv.Atoui64(string(data))
		// TODO: check for overflow?
		return err == nil
	}
	var ftmp float64
	getFloat64 := func() bool {
		ftmp, err = strconv.Atof64(string(data))
		// TODO: check for overflow?
		return err == nil
	}

	// Save accumulated data and comments
	switch t := saveData.(type) {
	case nil:
		// Probably a comment, handled below
	default:
		return os.ErrorString("cannot happen: unknown type " + t.Type().String())
	case *reflect.IntValue:
		if !getInt64() {
			return err
		}
		t.Set(int(itmp))
	case *reflect.Int8Value:
		if !getInt64() {
			return err
		}
		t.Set(int8(itmp))
	case *reflect.Int16Value:
		if !getInt64() {
			return err
		}
		t.Set(int16(itmp))
	case *reflect.Int32Value:
		if !getInt64() {
			return err
		}
		t.Set(int32(itmp))
	case *reflect.Int64Value:
		if !getInt64() {
			return err
		}
		t.Set(itmp)
	case *reflect.UintValue:
		if !getUint64() {
			return err
		}
		t.Set(uint(utmp))
	case *reflect.Uint8Value:
		if !getUint64() {
			return err
		}
		t.Set(uint8(utmp))
	case *reflect.Uint16Value:
		if !getUint64() {
			return err
		}
		t.Set(uint16(utmp))
	case *reflect.Uint32Value:
		if !getUint64() {
			return err
		}
		t.Set(uint32(utmp))
	case *reflect.Uint64Value:
		if !getUint64() {
			return err
		}
		t.Set(utmp)
	case *reflect.UintptrValue:
		if !getUint64() {
			return err
		}
		t.Set(uintptr(utmp))
	case *reflect.FloatValue:
		if !getFloat64() {
			return err
		}
		t.Set(float(ftmp))
	case *reflect.Float32Value:
		if !getFloat64() {
			return err
		}
		t.Set(float32(ftmp))
	case *reflect.Float64Value:
		if !getFloat64() {
			return err
		}
		t.Set(ftmp)
	case *reflect.StringValue:
		t.Set(string(data))
	case *reflect.SliceValue:
		t.Set(reflect.NewValue(data).(*reflect.SliceValue))
	}

	switch t := saveComment.(type) {
	case *reflect.StringValue:
		t.Set(string(comment))
	case *reflect.SliceValue:
		t.Set(reflect.NewValue(comment).(*reflect.SliceValue))
	}

	return nil
}
Ejemplo n.º 20
0
func main() {
	pg_adr, err := net.ResolveTCPAddr("152.7.16.113:5432")
	if err != nil {
		log.Exitf("Error while resolving address: %s", err)
	}
	conn, err := net.DialTCP("tcp", nil, pg_adr)
	if err != nil {
		log.Exitf("Error while connecting: %s", err)
	}
	log.Stdout("I think we connected")

	strs := make([]string, 4)
	strs[0] = "user"
	strs[1] = "alex"
	strs[2] = "database"
	strs[3] = "ar_test"
	str2 := strings.Join(strs, "\x00") + "\x00\x00"

	mesg2 := strings.Bytes(str2)
	hmesg := make([]byte, 4+4)
	binary.BigEndian.PutUint32(hmesg[4:8], uint32(3<<16))
	hmesg = bytes.Add(hmesg, mesg2)
	binary.BigEndian.PutUint32(hmesg[0:4], uint32(len(hmesg)))
	n, err := conn.Write(hmesg)

	if err != nil {
		log.Exitf("Error writing TCP: %s", err)
	}
	log.Stdoutf("wrote %d", n)

	result := make([]byte, 12)
	// the largest response we can get is 12 bytes
	if n, err = conn.Read(result); err != nil {
		log.Exitf("Error reading TCP (Read %d bytes): %s", n, err)
	}
	log.Stdoutf("%c", result[0])

	switch string(result[0]) {
	case psql_constants.Authentication:
		log.Stdout("Got authentication message")
	default:
		log.Exit("Did not get authentication message")
	}

	mesglen := binary.BigEndian.Uint32(result[1:5])
	mesgtype := binary.BigEndian.Uint32(result[5:9])

	fmt.Println(mesglen, mesgtype)

	passhash := md5.New()
	passhash.Write(strings.Bytes("jar1!" + "alex"))
	salthash := md5.New()
	salthash.Write(passhash.Sum())
	salthash.Write(result[9:12])

	passresponse := make([]byte, 5)
	passresponse[0] = 'p'
	binary.BigEndian.PutUint32(passresponse[1:5], uint32(4+salthash.Size()+1))
	passresponse = bytes.Add(passresponse, strings.Bytes("md5"))
	passresponse = bytes.Add(passresponse, salthash.Sum())
	passresponse = bytes.AddByte(passresponse, byte(0))
	fmt.Println(passresponse)
	n, err = conn.Write(passresponse)
	if err != nil {
		log.Exitf("Error writing TCP: %s", err)
	}
	log.Stdoutf("wrote %d", n)

	result = make([]byte, 18)
	// the largest response we can get is 12 bytes
	if n, err = conn.Read(result); err != nil {
		log.Exitf("Error reading TCP (Read %d bytes): %s", n, err)
	}
	fmt.Println(result)

	conn.Close()
}
Ejemplo n.º 21
0
func (c *Client) run(complete chan bool) {
	print("client running\n")
	print("sending handshake\n")
	c.HandShake()
	print("waiting for handshake\n")
	if !c.WaitHandShake() {
		complete <- false
		return
	}

	c.processHandShake(msg)
	blank := make([]byte, 9)
	msg := make([]byte, 49+pstrlen)
	buffer := bytes.NewBuffer(msg)
	buffer.WriteByte(pstrlen)
	buffer.WriteString(c.torrent.Pstr)
	buffer.Write(blank)
	buffer.Write(&(c.torrent.info_hash))
	buffer.Write(&(c.torrent.peer_id))
	_, err = c.conn.Write(buffer.Bytes())
	return

	for {
		print("waiting for msg\n")
		_, err := c.conn.Read(c.buffer[0:4]) //read msg length
		if err != nil {
			complete <- false
			return
		}

		length := binary.BigEndian.Uint32(c.buffer[0:4])
		print("recieved msg length" + strconv.Itoa(int(length)) + "\n")
		switch {
		case length == 0:
			print("keepalive msg")
			continue

		case length >= MaxInMsgSize:
			complete <- true
			return
		}
		_, err = c.conn.Read(c.buffer[4 : 4+length])
		if err != nil {
			complete <- true
			return
		}
		print("msg recieved payload\n")
		msg := new(message)
		msg.length = length
		msg.msgId = c.buffer[4]
		bytes.Add(msg.payLoad, c.buffer[5:len(c.buffer)])
		err = c.processMsg(msg)
		if err != nil {
			print(err.String())
			complete <- true
			return
		}
		runtime.Gosched()

	}

}
Ejemplo n.º 22
0
func main() {
	flag.Parse()                  // parsovani parametru prikazove radky
	rand.Seed(time.Nanoseconds()) // inicializace generatoru nahodnych cisel

	if *generateKeys {
		SaveKeys(GenerateKeys(*keyLength))
	}

	// rozdeleni souboru na vice mensich podle delky klice
	if *splitFile != "" {
		rights := 0600
		n, _ := ReadPublicKey()
		bytes := readFile(*splitFile)
		nl := len(n.Bytes()) - 1

		i := 0
		for ; i < len(bytes)/nl; i++ {
			writeToFile(partfile(i), bytes[i*nl:(i+1)*nl], rights)
		}
		if len(bytes[i*nl:]) > 0 { // pokud deleni nevychazi presne
			writeToFile(partfile(i), bytes[i*nl:], rights)
			i++
		}

		// informacni soubor
		writeToFile(*prefix+".info", strings.Bytes(fmt.Sprintf("%d", i)), rights)
	}

	// zasifruje/rozsifruje vsechny soubory verejnym klicem
	if *encrypFiles {
		n, e := ReadPublicKey()
		max := msgscount()

		for i := 0; i < max; i++ {
			file := readFile(partfile(i))
			bs := crypt(e, n, file)
			writeToFile(partfile(i), bs, 0600)
		}
	}

	// rozsifruje/zasifruje vsechny soubory soukromym klicem
	if *decrypFiles {
		p, q, d := ReadPrivateKey()
		pinv := new(big.Int).Mul(p, invMod(p, q)) // = p*(p^-1 mod q)
		qinv := new(big.Int).Mul(q, invMod(q, p)) // = q*(q^-1 mod p)

		n := new(big.Int).Mul(p, q)
		max := msgscount()

		for i := 0; i < max; i++ {
			file := readFile(partfile(i))

			// CINSKA VETA O ZBYTCICH
			bp := new(big.Int).SetBytes(crypt(d, p, file)) // decrypt mod p
			bq := new(big.Int).SetBytes(crypt(d, q, file)) // decrypt mod q

			// bs = bp * qinv + bq * binv (mod n)
			bs := new(big.Int).Mul(bp, qinv)
			bs.Add(bs, new(big.Int).Mul(bq, pinv))
			bs.Mod(bs, n)
			writeToFile(partfile(i), bs.Bytes(), 0600)
		}
	}

	// spojeni souboru do jednoho
	if *joinFile != "" {
		max := msgscount()
		var bs []byte

		for i := 0; i < max; i++ {
			file := readFile(partfile(i))
			bs = bytes.Add(bs, file)
		}

		writeToFile(*joinFile, bs, 0600)
	}
}