package dbus import ( "bytes" "encoding/binary" "errors" "io" "reflect" "strconv" ) const protoVersion byte = 1 // Flags represents the possible flags of a D-Bus message. type Flags byte const ( // FlagNoReplyExpected signals that the message is not expected to generate // a reply. If this flag is set on outgoing messages, any possible reply // will be discarded. FlagNoReplyExpected Flags = 1 << iota // FlagNoAutoStart signals that the message bus should not automatically // start an application when handling this message. FlagNoAutoStart // FlagAllowInteractiveAuthorization may be set on a method call // message to inform the receiving side that the caller is prepared // to wait for interactive authorization, which might take a // considerable time to complete. For instance, if this flag is set, // it would be appropriate to query the user for passwords or // confirmation via Polkit or a similar framework. FlagAllowInteractiveAuthorization ) // Type represents the possible types of a D-Bus message. type Type byte const ( TypeMethodCall Type = 1 + iota TypeMethodReply TypeError TypeSignal typeMax ) func (t Type) String() string { switch t { case TypeMethodCall: return "method call" case TypeMethodReply: return "reply" case TypeError: return "error" case TypeSignal: return "signal" } return "invalid" } // HeaderField represents the possible byte codes for the headers // of a D-Bus message. type HeaderField byte const ( FieldPath HeaderField = 1 + iota FieldInterface FieldMember FieldErrorName FieldReplySerial FieldDestination FieldSender FieldSignature FieldUnixFDs fieldMax ) // An InvalidMessageError describes the reason why a D-Bus message is regarded as // invalid. type InvalidMessageError string func (e InvalidMessageError) Error() string { return "dbus: invalid message: " + string(e) } // fieldType are the types of the various header fields. var fieldTypes = [fieldMax]reflect.Type{ FieldPath: objectPathType, FieldInterface: stringType, FieldMember: stringType, FieldErrorName: stringType, FieldReplySerial: uint32Type, FieldDestination: stringType, FieldSender: stringType, FieldSignature: signatureType, FieldUnixFDs: uint32Type, } // requiredFields lists the header fields that are required by the different // message types. var requiredFields = [typeMax][]HeaderField{ TypeMethodCall: {FieldPath, FieldMember}, TypeMethodReply: {FieldReplySerial}, TypeError: {FieldErrorName, FieldReplySerial}, TypeSignal: {FieldPath, FieldInterface, FieldMember}, } // Message represents a single D-Bus message. type Message struct { Type Flags Headers map[HeaderField]Variant Body []interface{} serial uint32 } type header struct { Field byte Variant } // DecodeMessage tries to decode a single message in the D-Bus wire format // from the given reader. The byte order is figured out from the first byte. // The possibly returned error can be an error of the underlying reader, an // InvalidMessageError or a FormatError. func DecodeMessage(rd io.Reader) (msg *Message, err error) { var order binary.ByteOrder var hlength, length uint32 var typ, flags, proto byte var headers []header b := make([]byte, 1) _, err = rd.Read(b) if err != nil { return } switch b[0] { case 'l': order = binary.LittleEndian case 'B': order = binary.BigEndian default: return nil, InvalidMessageError("invalid byte order") } dec := newDecoder(rd, order) dec.pos = 1 msg = new(Message) vs, err := dec.Decode(Signature{"yyyuu"}) if err != nil { return nil, err } if err = Store(vs, &typ, &flags, &proto, &length, &msg.serial); err != nil { return nil, err } msg.Type = Type(typ) msg.Flags = Flags(flags) // get the header length separately because we need it later b = make([]byte, 4) _, err = io.ReadFull(rd, b) if err != nil { return nil, err } binary.Read(bytes.NewBuffer(b), order, &hlength) if hlength+length+16 > 1<<27 { return nil, InvalidMessageError("message is too long") } dec = newDecoder(io.MultiReader(bytes.NewBuffer(b), rd), order) dec.pos = 12 vs, err = dec.Decode(Signature{"a(yv)"}) if err != nil { return nil, err } if err = Store(vs, &headers); err != nil { return nil, err } msg.Headers = make(map[HeaderField]Variant) for _, v := range headers { msg.Headers[HeaderField(v.Field)] = v.Variant } dec.align(8) body := make([]byte, int(length)) if length != 0 { _, err := io.ReadFull(rd, body) if err != nil { return nil, err } } if err = msg.IsValid(); err != nil { return nil, err } sig, _ := msg.Headers[FieldSignature].value.(Signature) if sig.str != "" { buf := bytes.NewBuffer(body) dec = newDecoder(buf, order) vs, err := dec.Decode(sig) if err != nil { return nil, err } msg.Body = vs } return } // EncodeTo encodes and sends a message to the given writer. The byte order must // be either binary.LittleEndian or binary.BigEndian. If the message is not // valid or an error occurs when writing, an error is returned. func (msg *Message) EncodeTo(out io.Writer, order binary.ByteOrder) error { if err := msg.IsValid(); err != nil { return err } var vs [7]interface{} switch order { case binary.LittleEndian: vs[0] = byte('l') case binary.BigEndian: vs[0] = byte('B') default: return errors.New("dbus: invalid byte order") } body := new(bytes.Buffer) enc := newEncoder(body, order) if len(msg.Body) != 0 { enc.Encode(msg.Body...) } vs[1] = msg.Type vs[2] = msg.Flags vs[3] = protoVersion vs[4] = uint32(len(body.Bytes())) vs[5] = msg.serial headers := make([]header, 0, len(msg.Headers)) for k, v := range msg.Headers { headers = append(headers, header{byte(k), v}) } vs[6] = headers var buf bytes.Buffer enc = newEncoder(&buf, order) enc.Encode(vs[:]...) enc.align(8) body.WriteTo(&buf) if buf.Len() > 1<<27 { return InvalidMessageError("message is too long") } if _, err := buf.WriteTo(out); err != nil { return err } return nil } // IsValid checks whether msg is a valid message and returns an // InvalidMessageError if it is not. func (msg *Message) IsValid() error { if msg.Flags & ^(FlagNoAutoStart|FlagNoReplyExpected|FlagAllowInteractiveAuthorization) != 0 { return InvalidMessageError("invalid flags") } if msg.Type == 0 || msg.Type >= typeMax { return InvalidMessageError("invalid message type") } for k, v := range msg.Headers { if k == 0 || k >= fieldMax { return InvalidMessageError("invalid header") } if reflect.TypeOf(v.value) != fieldTypes[k] { return InvalidMessageError("invalid type of header field") } } for _, v := range requiredFields[msg.Type] { if _, ok := msg.Headers[v]; !ok { return InvalidMessageError("missing required header") } } if path, ok := msg.Headers[FieldPath]; ok { if !path.value.(ObjectPath).IsValid() { return InvalidMessageError("invalid path name") } } if iface, ok := msg.Headers[FieldInterface]; ok { if !isValidInterface(iface.value.(string)) { return InvalidMessageError("invalid interface name") } } if member, ok := msg.Headers[FieldMember]; ok { if !isValidMember(member.value.(string)) { return InvalidMessageError("invalid member name") } } if errname, ok := msg.Headers[FieldErrorName]; ok { if !isValidInterface(errname.value.(string)) { return InvalidMessageError("invalid error name") } } if len(msg.Body) != 0 { if _, ok := msg.Headers[FieldSignature]; !ok { return InvalidMessageError("missing signature") } } return nil } // Serial returns the message's serial number. The returned value is only valid // for messages received by eavesdropping. func (msg *Message) Serial() uint32 { return msg.serial } // String returns a string representation of a message similar to the format of // dbus-monitor. func (msg *Message) String() string { if err := msg.IsValid(); err != nil { return "<invalid>" } s := msg.Type.String() if v, ok := msg.Headers[FieldSender]; ok { s += " from " + v.value.(string) } if v, ok := msg.Headers[FieldDestination]; ok { s += " to " + v.value.(string) } s += " serial " + strconv.FormatUint(uint64(msg.serial), 10) if v, ok := msg.Headers[FieldReplySerial]; ok { s += " reply_serial " + strconv.FormatUint(uint64(v.value.(uint32)), 10) } if v, ok := msg.Headers[FieldUnixFDs]; ok { s += " unixfds " + strconv.FormatUint(uint64(v.value.(uint32)), 10) } if v, ok := msg.Headers[FieldPath]; ok { s += " path " + string(v.value.(ObjectPath)) } if v, ok := msg.Headers[FieldInterface]; ok { s += " interface " + v.value.(string) } if v, ok := msg.Headers[FieldErrorName]; ok { s += " error " + v.value.(string) } if v, ok := msg.Headers[FieldMember]; ok { s += " member " + v.value.(string) } if len(msg.Body) != 0 { s += "\n" } for i, v := range msg.Body { s += " " + MakeVariant(v).String() if i != len(msg.Body)-1 { s += "\n" } } return s }