diff --git a/client/client.go b/client/client.go
index 8148a7b..ceab57f 100644
--- a/client/client.go
+++ b/client/client.go
@@ -13,13 +13,13 @@
 
 import (
 	"errors"
+	P "git.eclipse.org/gitroot/paho.incubator/smidge.git/packets"
 	"net"
 	"net/url"
-	. "smidge/packets"
 	"sync"
 )
 
-type MessageHandler func(client *SNClient, message *PublishMessage)
+type MessageHandler func(client *SNClient, message *P.PublishMessage)
 
 type Will struct {
 	Topic  string
@@ -41,7 +41,7 @@
 type SNClient struct {
 	sync.RWMutex
 	ClientId                  string
-	OutstandingMessages       map[uint16]Message
+	OutstandingMessages       map[uint16]P.Message
 	RegisteredTopics          map[string]uint16
 	MessageHandlers           map[uint16]MessageHandler
 	PredefinedTopics          map[string]uint16
@@ -51,7 +51,7 @@
 	will                      Will
 	suTokens                  map[int]Token
 	conn                      net.Conn
-	incoming                  chan Message
+	incoming                  chan P.Message
 	outgoing                  chan *MessageAndToken
 	stop                      chan struct{}
 	state                     byte
@@ -75,7 +75,7 @@
 	c.PredefinedTopics = make(map[string]uint16)
 	c.PredefinedMessageHandlers = make(map[uint16]MessageHandler)
 	c.suTokens = make(map[int]Token)
-	c.incoming = make(chan Message)
+	c.incoming = make(chan P.Message)
 	c.outgoing = make(chan *MessageAndToken)
 	c.stop = make(chan struct{})
 	c.MessageIds.index = make(map[uint16]Token)
@@ -94,9 +94,9 @@
 
 func (c *SNClient) Connect() *ConnectToken {
 	c.setState(CONNECTING)
-	ct := newToken(CONNECT).(*ConnectToken)
-	c.suTokens[CONNECT] = ct
-	cp := NewMessage(CONNECT).(*ConnectMessage)
+	ct := newToken(P.CONNECT).(*ConnectToken)
+	c.suTokens[P.CONNECT] = ct
+	cp := P.NewMessage(P.CONNECT).(*P.ConnectMessage)
 	cp.CleanSession = true
 	cp.ClientId = []byte(c.ClientId)
 	cp.Duration = 30
@@ -118,19 +118,19 @@
 }
 
 func (c *SNClient) Register(topic string) *RegisterToken {
-	t := newToken(REGISTER).(*RegisterToken)
+	t := newToken(P.REGISTER).(*RegisterToken)
 	t.TopicName = topic
-	r := NewMessage(REGISTER).(*RegisterMessage)
+	r := P.NewMessage(P.REGISTER).(*P.RegisterMessage)
 	r.TopicName = []byte(topic)
 	c.outgoing <- &MessageAndToken{m: r, t: t}
 	return t
 }
 
 func (c *SNClient) Subscribe(topic string, qos byte, mh MessageHandler) *SubscribeToken {
-	t := newToken(SUBSCRIBE).(*SubscribeToken)
+	t := newToken(P.SUBSCRIBE).(*SubscribeToken)
 	t.handler = mh
 	t.TopicName = topic
-	s := NewMessage(SUBSCRIBE).(*SubscribeMessage)
+	s := P.NewMessage(P.SUBSCRIBE).(*P.SubscribeMessage)
 	if len(topic) > 2 {
 		s.TopicIdType = 0x00
 		t.topicType = 0x00
@@ -145,10 +145,10 @@
 }
 
 func (c *SNClient) SubscribePredefined(topicid uint16, qos byte, mh MessageHandler) *SubscribeToken {
-	t := newToken(SUBSCRIBE).(*SubscribeToken)
+	t := newToken(P.SUBSCRIBE).(*SubscribeToken)
 	t.handler = mh
 	t.topicType = 0x01
-	s := NewMessage(SUBSCRIBE).(*SubscribeMessage)
+	s := P.NewMessage(P.SUBSCRIBE).(*P.SubscribeMessage)
 	s.TopicIdType = 0x01
 	s.TopicId = topicid
 	s.Qos = qos
@@ -157,8 +157,8 @@
 }
 
 func (c *SNClient) Publish(topic string, qos byte, retain bool, data []byte) *PublishToken {
-	t := newToken(PUBLISH).(*PublishToken)
-	p := NewMessage(PUBLISH).(*PublishMessage)
+	t := newToken(P.PUBLISH).(*PublishToken)
+	p := P.NewMessage(P.PUBLISH).(*P.PublishMessage)
 	p.TopicId = c.RegisteredTopics[topic]
 	p.Qos = qos
 	p.Retain = retain
@@ -168,8 +168,8 @@
 }
 
 func (c *SNClient) PublishPredefined(topicid uint16, qos byte, retain bool, data []byte) *PublishToken {
-	t := newToken(PUBLISH).(*PublishToken)
-	p := NewMessage(PUBLISH).(*PublishMessage)
+	t := newToken(P.PUBLISH).(*PublishToken)
+	p := P.NewMessage(P.PUBLISH).(*P.PublishMessage)
 	p.TopicIdType = 0x01
 	p.TopicId = topicid
 	p.Qos = qos
@@ -189,9 +189,9 @@
 
 func (c *SNClient) SetWillTopic(t string) *WillToken {
 	c.will.Topic = t
-	wt := newToken(WILLTOPIC).(*WillToken)
+	wt := newToken(P.WILLTOPIC).(*WillToken)
 	if c.state != UNCONNECTED {
-		wm := NewMessage(WILLTOPICUPD).(*WillTopicUpdateMessage)
+		wm := P.NewMessage(P.WILLTOPICUPD).(*P.WillTopicUpdateMessage)
 		wm.Qos = c.will.Qos
 		wm.Retain = c.will.Retain
 		c.outgoing <- &MessageAndToken{m: wm, t: wt}
@@ -203,9 +203,9 @@
 
 func (c *SNClient) SetWillQos(q byte) *WillToken {
 	c.will.Qos = q
-	wt := newToken(WILLTOPIC).(*WillToken)
+	wt := newToken(P.WILLTOPIC).(*WillToken)
 	if c.state != UNCONNECTED {
-		wm := NewMessage(WILLTOPICUPD).(*WillTopicUpdateMessage)
+		wm := P.NewMessage(P.WILLTOPICUPD).(*P.WillTopicUpdateMessage)
 		wm.Qos = c.will.Qos
 		wm.Retain = c.will.Retain
 		c.outgoing <- &MessageAndToken{m: wm, t: wt}
@@ -217,9 +217,9 @@
 
 func (c *SNClient) SetWillRetain(r bool) *WillToken {
 	c.will.Retain = r
-	wt := newToken(WILLTOPIC).(*WillToken)
+	wt := newToken(P.WILLTOPIC).(*WillToken)
 	if c.state != UNCONNECTED {
-		wm := NewMessage(WILLTOPICUPD).(*WillTopicUpdateMessage)
+		wm := P.NewMessage(P.WILLTOPICUPD).(*P.WillTopicUpdateMessage)
 		wm.Qos = c.will.Qos
 		wm.Retain = c.will.Retain
 		c.outgoing <- &MessageAndToken{m: wm, t: wt}
@@ -232,9 +232,9 @@
 func (c *SNClient) SetWillData(d []byte) *WillToken {
 	c.will.Data = make([]byte, len(d))
 	copy(c.will.Data, d)
-	wt := newToken(WILLMSGUPD).(*WillToken)
+	wt := newToken(P.WILLMSGUPD).(*WillToken)
 	if c.state != UNCONNECTED {
-		wm := NewMessage(WILLMSGUPD).(*WillMsgUpdateMessage)
+		wm := P.NewMessage(P.WILLMSGUPD).(*P.WillMsgUpdateMessage)
 		c.outgoing <- &MessageAndToken{m: wm, t: wt}
 		return wt
 	}
diff --git a/client/net.go b/client/net.go
index c45cbbf..759afb4 100644
--- a/client/net.go
+++ b/client/net.go
@@ -12,19 +12,19 @@
 package smidge
 
 import (
-	. "smidge/packets"
+	P "git.eclipse.org/gitroot/paho.incubator/smidge.git/packets"
 )
 
 func (c *SNClient) receive() {
 	var err error
-	var m Message
+	var m P.Message
 
 	DEBUG.Println(NET, "started receive()")
 	for {
-		if m, err = ReadPacket(c.conn); err != nil {
+		if m, err = P.ReadPacket(c.conn); err != nil {
 			break
 		}
-		DEBUG.Println(NET, "Received", MessageNames[m.MessageType()])
+		DEBUG.Println(NET, "Received", P.MessageNames[m.MessageType()])
 		c.incoming <- m
 	}
 
@@ -41,19 +41,19 @@
 	DEBUG.Println(NET, "started send()")
 	for {
 		mt := <-c.outgoing
-		DEBUG.Println(NET, "sending message", MessageNames[mt.m.MessageType()])
+		DEBUG.Println(NET, "sending message", P.MessageNames[mt.m.MessageType()])
 		switch mt.m.MessageType() {
-		case REGISTER:
-			mt.m.(*RegisterMessage).MessageId = c.MessageIds.getId(mt.t)
-		case PUBLISH:
-			mt.m.(*PublishMessage).MessageId = c.MessageIds.getId(mt.t)
-		case SUBSCRIBE:
-			mt.m.(*SubscribeMessage).MessageId = c.MessageIds.getId(mt.t)
-		case UNSUBSCRIBE:
-			mt.m.(*UnsubscribeMessage).MessageId = c.MessageIds.getId(mt.t)
+		case P.REGISTER:
+			mt.m.(*P.RegisterMessage).MessageId = c.MessageIds.getId(mt.t)
+		case P.PUBLISH:
+			mt.m.(*P.PublishMessage).MessageId = c.MessageIds.getId(mt.t)
+		case P.SUBSCRIBE:
+			mt.m.(*P.SubscribeMessage).MessageId = c.MessageIds.getId(mt.t)
+		case P.UNSUBSCRIBE:
+			mt.m.(*P.UnsubscribeMessage).MessageId = c.MessageIds.getId(mt.t)
 		}
 		mt.m.Write(c.conn)
-		if mt.m.MessageType() == DISCONNECT {
+		if mt.m.MessageType() == P.DISCONNECT {
 			DEBUG.Println(NET, "Sent DISCONNECT, closing connection")
 			c.conn.Close()
 			return
@@ -66,28 +66,28 @@
 	for {
 		select {
 		case m := <-c.incoming:
-			DEBUG.Println(NET, "got message off <-incoming", MessageNames[m.MessageType()])
+			DEBUG.Println(NET, "got message off <-incoming", P.MessageNames[m.MessageType()])
 			switch m.MessageType() {
-			case CONNACK:
-				ca := m.(*ConnackMessage)
+			case P.CONNACK:
+				ca := m.(*P.ConnackMessage)
 				c.setState(CONNECTED)
-				ct := c.suTokens[CONNECT].(*ConnectToken)
+				ct := c.suTokens[P.CONNECT].(*ConnectToken)
 				ct.ReturnCode = ca.ReturnCode
 				ct.flowComplete()
-			case REGISTER:
-				r := m.(*RegisterMessage)
+			case P.REGISTER:
+				r := m.(*P.RegisterMessage)
 				c.RegisteredTopics[string(r.TopicName)] = r.TopicId
-				ra := NewMessage(REGACK).(*RegackMessage)
+				ra := P.NewMessage(P.REGACK).(*P.RegackMessage)
 				ra.MessageId = r.MessageId
 				ra.TopicId = r.TopicId
-				ra.ReturnCode = ACCEPTED
+				ra.ReturnCode = P.ACCEPTED
 				c.outgoing <- &MessageAndToken{m: ra, t: nil}
-			case REGACK:
-				ra := m.(*RegackMessage)
+			case P.REGACK:
+				ra := m.(*P.RegackMessage)
 				t := c.MessageIds.getToken(ra.MessageId).(*RegisterToken)
 				t.ReturnCode = ra.ReturnCode
 				switch ra.ReturnCode {
-				case ACCEPTED:
+				case P.ACCEPTED:
 					DEBUG.Println(NET, t.TopicName, "registered as", ra.TopicId)
 					c.RegisteredTopics[t.TopicName] = ra.TopicId
 					t.TopicId = ra.TopicId
@@ -95,12 +95,12 @@
 					ERROR.Println(NET, ra.ReturnCode, "for REGISTER for", string(t.TopicName))
 				}
 				t.flowComplete()
-			case SUBACK:
-				sa := m.(*SubackMessage)
+			case P.SUBACK:
+				sa := m.(*P.SubackMessage)
 				t := c.MessageIds.getToken(sa.MessageId).(*SubscribeToken)
 				t.ReturnCode = sa.ReturnCode
 				switch sa.ReturnCode {
-				case ACCEPTED:
+				case P.ACCEPTED:
 					t.Qos = sa.Qos
 					if sa.TopicId > 0x00 {
 						t.TopicId = sa.TopicId
@@ -116,8 +116,8 @@
 					ERROR.Println(NET, sa.ReturnCode, "for SUBSCRIBE to", t.TopicName)
 				}
 				t.flowComplete()
-			case PUBLISH:
-				p := m.(*PublishMessage)
+			case P.PUBLISH:
+				p := m.(*P.PublishMessage)
 				switch p.TopicIdType {
 				case 0x00:
 					if handler, ok := c.MessageHandlers[p.TopicId]; ok {
@@ -128,24 +128,24 @@
 						go c.DefaultMessageHandler(c, p)
 					}
 				}
-			case PUBACK:
-				pa := m.(*PubackMessage)
+			case P.PUBACK:
+				pa := m.(*P.PubackMessage)
 				t := c.MessageIds.getToken(pa.MessageId).(*PublishToken)
 				t.ReturnCode = pa.ReturnCode
 				t.TopicId = pa.TopicId
 				t.flowComplete()
-			case DISCONNECT:
+			case P.DISCONNECT:
 				c.setState(UNCONNECTED)
 				DEBUG.Println(NET, "Received DISCONNECT, closing socket")
 				c.conn.Close()
-			case WILLTOPICREQ:
-				wm := NewMessage(WILLTOPIC).(*WillTopicMessage)
+			case P.WILLTOPICREQ:
+				wm := P.NewMessage(P.WILLTOPIC).(*P.WillTopicMessage)
 				wm.WillTopic = []byte(c.will.Topic)
 				wm.Qos = c.will.Qos
 				wm.Retain = c.will.Retain
 				c.outgoing <- &MessageAndToken{m: wm, t: nil}
-			case WILLMSGREQ:
-				wm := NewMessage(WILLMSG).(*WillMsgMessage)
+			case P.WILLMSGREQ:
+				wm := P.NewMessage(P.WILLMSG).(*P.WillMsgMessage)
 				wm.WillMsg = c.will.Data
 				c.outgoing <- &MessageAndToken{m: wm, t: nil}
 			}
diff --git a/client/samples/simple.go b/client/samples/simple.go
index 542d71c..8d1b9c8 100644
--- a/client/samples/simple.go
+++ b/client/samples/simple.go
@@ -13,10 +13,10 @@
 
 import (
 	"fmt"
+	"git.eclipse.org/gitroot/paho.incubator/smidge.git/client"
+	"git.eclipse.org/gitroot/paho.incubator/smidge.git/packets"
 	"log"
 	"os"
-	"smidge/client"
-	"smidge/packets"
 	"time"
 )
 
diff --git a/client/samples/simple2.go b/client/samples/simple2.go
index 77f8b4d..874c300 100644
--- a/client/samples/simple2.go
+++ b/client/samples/simple2.go
@@ -13,10 +13,10 @@
 
 import (
 	"fmt"
+	"git.eclipse.org/gitroot/paho.incubator/smidge.git/client"
+	"git.eclipse.org/gitroot/paho.incubator/smidge.git/packets"
 	"log"
 	"os"
-	"smidge/client"
-	"smidge/packets"
 	"time"
 )
 
diff --git a/client/token.go b/client/token.go
index 0747ba3..be90f23 100644
--- a/client/token.go
+++ b/client/token.go
@@ -12,12 +12,12 @@
 package smidge
 
 import (
-	. "smidge/packets"
+	P "git.eclipse.org/gitroot/paho.incubator/smidge.git/packets"
 	"time"
 )
 
 type MessageAndToken struct {
-	m Message
+	m P.Message
 	t Token
 }
 
@@ -59,17 +59,17 @@
 
 func newToken(tType byte) Token {
 	switch tType {
-	case CONNECT:
+	case P.CONNECT:
 		return &ConnectToken{baseToken: baseToken{complete: make(chan struct{})}}
-	case REGISTER:
+	case P.REGISTER:
 		return &RegisterToken{baseToken: baseToken{complete: make(chan struct{})}}
-	case SUBSCRIBE:
+	case P.SUBSCRIBE:
 		return &SubscribeToken{baseToken: baseToken{complete: make(chan struct{})}}
-	case PUBLISH:
+	case P.PUBLISH:
 		return &PublishToken{baseToken: baseToken{complete: make(chan struct{})}}
-	case UNSUBSCRIBE:
+	case P.UNSUBSCRIBE:
 		return &UnsubscribeToken{baseToken: baseToken{complete: make(chan struct{})}}
-	case WILLTOPIC, WILLMSG, WILLMSGUPD, WILLTOPICUPD:
+	case P.WILLTOPIC, P.WILLMSG, P.WILLMSGUPD, P.WILLTOPICUPD:
 		return &WillToken{baseToken: baseToken{complete: make(chan struct{})}}
 	}
 	return nil
diff --git a/gateway/gate/aggregatinggateway.go b/gateway/gate/aggregatinggateway.go
index 9020bc0..fa1312b 100644
--- a/gateway/gate/aggregatinggateway.go
+++ b/gateway/gate/aggregatinggateway.go
@@ -22,7 +22,7 @@
 
 	MQTT "git.eclipse.org/gitroot/paho/org.eclipse.paho.mqtt.golang.git"
 
-	. "smidge/packets"
+	P "git.eclipse.org/gitroot/paho.incubator/smidge.git/packets"
 )
 
 type AGateway struct {
@@ -130,7 +130,7 @@
 	topicid := ag.tIndex.getId(msg.Topic())
 	// topicidtype := byte(0x00) // todo: pre-defined (1) and shortname (2)
 	// msgid := uint16(0x00) // todo: what should this be??
-	pm := NewPublishMessage(topicid, 0x00, msg.Payload(), msg.Qos(), 0x00, msg.Retained(), msg.Duplicate())
+	pm := P.NewPublishMessage(topicid, 0x00, msg.Payload(), msg.Qos(), 0x00, msg.Retained(), msg.Duplicate())
 
 	if client.Registered(topicid) {
 		INFO.Printf("client \"%s\" already registered to %d, publish ahoy!\n", client, topicid)
@@ -141,7 +141,7 @@
 		}
 	} else {
 		INFO.Printf("client \"%s\" is not registered to %d, must REGISTER first\n", client, topicid)
-		rm := NewRegisterMessage(topicid, 0x00, []byte(msg.Topic()))
+		rm := P.NewRegisterMessage(topicid, 0x00, []byte(msg.Topic()))
 		client.AddPendingMessage(pm)
 		if err := client.Write(rm); err != nil {
 			ERROR.Printf("error writing REGISTER to \"%s\"\n", client)
@@ -155,82 +155,82 @@
 	INFO.Printf("OnPacket!  - bytes: %s\n", string(buffer[0:nbytes]))
 
 	buf := bytes.NewBuffer(buffer)
-	rawmsg, _ := ReadPacket(buf)
+	rawmsg, _ := P.ReadPacket(buf)
 	INFO.Printf("rawmsg.MessageType(): %s\n", rawmsg.MessageType())
 
 	switch msg := rawmsg.(type) {
-	case *AdvertiseMessage:
+	case *P.AdvertiseMessage:
 		ag.handle_ADVERTISE(msg, addr)
-	case *SearchGwMessage:
+	case *P.SearchGwMessage:
 		ag.handle_SEARCHGW(msg, addr)
-	case *GwInfoMessage:
+	case *P.GwInfoMessage:
 		ag.handle_GWINFO(msg, addr)
-	case *ConnectMessage:
+	case *P.ConnectMessage:
 		ag.handle_CONNECT(msg, con, addr)
-	case *ConnackMessage:
+	case *P.ConnackMessage:
 		ag.handle_CONNACK(msg, addr)
-	case *WillTopicReqMessage:
+	case *P.WillTopicReqMessage:
 		ag.handle_WILLTOPICREQ(msg, addr)
-	case *WillTopicMessage:
+	case *P.WillTopicMessage:
 		ag.handle_WILLTOPIC(msg, addr)
-	case *WillMsgReqMessage:
+	case *P.WillMsgReqMessage:
 		ag.handle_WILLMSGREQ(msg, addr)
-	case *WillMsgMessage:
+	case *P.WillMsgMessage:
 		ag.handle_WILLMSG(msg, addr)
-	case *RegisterMessage:
+	case *P.RegisterMessage:
 		ag.handle_REGISTER(msg, con, addr)
-	case *RegackMessage:
+	case *P.RegackMessage:
 		ag.handle_REGACK(msg, addr)
-	case *PublishMessage:
+	case *P.PublishMessage:
 		ag.handle_PUBLISH(msg, addr)
-	case *PubackMessage:
+	case *P.PubackMessage:
 		ag.handle_PUBACK(msg, addr)
-	case *PubcompMessage:
+	case *P.PubcompMessage:
 		ag.handle_PUBCOMP(msg, addr)
-	case *PubrecMessage:
+	case *P.PubrecMessage:
 		ag.handle_PUBREC(msg, addr)
-	case *PubrelMessage:
+	case *P.PubrelMessage:
 		ag.handle_PUBREL(msg, addr)
-	case *SubscribeMessage:
+	case *P.SubscribeMessage:
 		ag.handle_SUBSCRIBE(msg, con, addr)
-	case *SubackMessage:
+	case *P.SubackMessage:
 		ag.handle_SUBACK(msg, addr)
-	case *UnsubscribeMessage:
+	case *P.UnsubscribeMessage:
 		ag.handle_UNSUBSCRIBE(msg, addr)
-	case *UnsubackMessage:
+	case *P.UnsubackMessage:
 		ag.handle_UNSUBACK(msg, addr)
-	case *PingreqMessage:
+	case *P.PingreqMessage:
 		ag.handle_PINGREQ(msg, con, addr)
-	case *PingrespMessage:
+	case *P.PingrespMessage:
 		ag.handle_PINGRESP(msg, addr)
-	case *DisconnectMessage:
+	case *P.DisconnectMessage:
 		ag.handle_DISCONNECT(msg, addr)
-	case *WillTopicUpdateMessage:
+	case *P.WillTopicUpdateMessage:
 		ag.handle_WILLTOPICUPD(msg, addr)
-	case *WillTopicRespMessage:
+	case *P.WillTopicRespMessage:
 		ag.handle_WILLTOPICRESP(msg, addr)
-	case *WillMsgUpdateMessage:
+	case *P.WillMsgUpdateMessage:
 		ag.handle_WILLMSGUPD(msg, addr)
-	case *WillMsgRespMessage:
+	case *P.WillMsgRespMessage:
 		ag.handle_WILLMSGRESP(msg, addr)
 	default:
 		ERROR.Printf("Unknown Message Type %T\n", msg)
 	}
 }
 
-func (ag *AGateway) handle_ADVERTISE(m *AdvertiseMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_ADVERTISE(m *P.AdvertiseMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_SEARCHGW(m *SearchGwMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_SEARCHGW(m *P.SearchGwMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_GWINFO(m *GwInfoMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_GWINFO(m *P.GwInfoMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_CONNECT(m *ConnectMessage, c *net.UDPConn, r *net.UDPAddr) {
+func (ag *AGateway) handle_CONNECT(m *P.ConnectMessage, c *net.UDPConn, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 
 	if clientid, e := validateClientId(m.ClientId); e != nil {
@@ -247,7 +247,7 @@
 		client := NewClient(clientid, c, r)
 		ag.clients.AddClient(client)
 
-		ca := NewMessage(CONNACK).(*ConnackMessage) // todo: 0 ?
+		ca := P.NewMessage(P.CONNACK).(*P.ConnackMessage) // todo: 0 ?
 		ca.ReturnCode = 0
 		if ioerr := client.Write(ca); ioerr != nil {
 			ERROR.Println(ioerr)
@@ -257,27 +257,27 @@
 	}
 }
 
-func (ag *AGateway) handle_CONNACK(m *ConnackMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_CONNACK(m *P.ConnackMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_WILLTOPICREQ(m *WillTopicReqMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_WILLTOPICREQ(m *P.WillTopicReqMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_WILLTOPIC(m *WillTopicMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_WILLTOPIC(m *P.WillTopicMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_WILLMSGREQ(m *WillMsgReqMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_WILLMSGREQ(m *P.WillMsgReqMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_WILLMSG(m *WillMsgMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_WILLMSG(m *P.WillMsgMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_REGISTER(m *RegisterMessage, c *net.UDPConn, r *net.UDPAddr) {
+func (ag *AGateway) handle_REGISTER(m *P.RegisterMessage, c *net.UDPConn, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 	topic := string(m.TopicName)
 	INFO.Printf("msg id: %d\n", m.MessageId)
@@ -295,7 +295,7 @@
 
 	INFO.Printf("ag topicid: %d\n", topicid)
 
-	ra := NewRegackMessage(topicid, m.MessageId, 0)
+	ra := P.NewRegackMessage(topicid, m.MessageId, 0)
 	INFO.Printf("ra.MsgId: %d\n", ra.MessageId)
 
 	if err := client.Write(ra); err != nil {
@@ -305,7 +305,7 @@
 	}
 }
 
-func (ag *AGateway) handle_REGACK(m *RegackMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_REGACK(m *P.RegackMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 	// the gateway sends a register when there is a message
 	// that needs to be published, so we do that now
@@ -323,7 +323,7 @@
 	}
 }
 
-func (ag *AGateway) handle_PUBLISH(m *PublishMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_PUBLISH(m *P.PublishMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 
 	INFO.Printf("m.TopicId: %d\n", m.TopicId)
@@ -338,23 +338,23 @@
 	INFO.Println("Message Published")
 }
 
-func (ag *AGateway) handle_PUBACK(m *PubackMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_PUBACK(m *P.PubackMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_PUBCOMP(m *PubcompMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_PUBCOMP(m *P.PubcompMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_PUBREC(m *PubrecMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_PUBREC(m *P.PubrecMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_PUBREL(m *PubrelMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_PUBREL(m *P.PubrelMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_SUBSCRIBE(m *SubscribeMessage, c *net.UDPConn, r *net.UDPAddr) {
+func (ag *AGateway) handle_SUBSCRIBE(m *P.SubscribeMessage, c *net.UDPConn, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 	INFO.Printf("m.TopicIdType: %d\n", m.TopicIdType)
 	topic := string(m.TopicName)
@@ -385,7 +385,7 @@
 		}
 		// AG is subscribed at this point
 		client.Register(topicid, topic)
-		suba := NewSubackMessage(topicid, m.MessageId, m.Qos, 0)
+		suba := P.NewSubackMessage(topicid, m.MessageId, m.Qos, 0)
 		var buf bytes.Buffer
 		suba.Write(&buf)
 		if nbytes, err := c.WriteToUDP(buf.Bytes(), r); err != nil {
@@ -396,21 +396,21 @@
 	}
 }
 
-func (ag *AGateway) handle_SUBACK(m *SubackMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_SUBACK(m *P.SubackMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_UNSUBSCRIBE(m *UnsubscribeMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_UNSUBSCRIBE(m *P.UnsubscribeMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_UNSUBACK(m *UnsubackMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_UNSUBACK(m *P.UnsubackMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_PINGREQ(m *PingreqMessage, c *net.UDPConn, r *net.UDPAddr) {
+func (ag *AGateway) handle_PINGREQ(m *P.PingreqMessage, c *net.UDPConn, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
-	resp := NewMessage(PINGRESP)
+	resp := P.NewMessage(P.PINGRESP)
 
 	var buf bytes.Buffer
 	resp.Write(&buf)
@@ -422,28 +422,28 @@
 	}
 }
 
-func (ag *AGateway) handle_PINGRESP(m *PingrespMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_PINGRESP(m *P.PingrespMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_DISCONNECT(m *DisconnectMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_DISCONNECT(m *P.DisconnectMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 	INFO.Printf("duration: %d\n", m.Duration)
 	// todo: cleanup the client
 }
 
-func (ag *AGateway) handle_WILLTOPICUPD(m *WillTopicUpdateMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_WILLTOPICUPD(m *P.WillTopicUpdateMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_WILLTOPICRESP(m *WillTopicRespMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_WILLTOPICRESP(m *P.WillTopicRespMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_WILLMSGUPD(m *WillMsgUpdateMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_WILLMSGUPD(m *P.WillMsgUpdateMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
 
-func (ag *AGateway) handle_WILLMSGRESP(m *WillMsgRespMessage, r *net.UDPAddr) {
+func (ag *AGateway) handle_WILLMSGRESP(m *P.WillMsgRespMessage, r *net.UDPAddr) {
 	INFO.Printf("handle_%s from %v\n", m.MessageType(), r)
 }
diff --git a/gateway/gate/client.go b/gateway/gate/client.go
index 827daa0..788a807 100644
--- a/gateway/gate/client.go
+++ b/gateway/gate/client.go
@@ -17,7 +17,7 @@
 	"net"
 	"sync"
 
-	. "smidge/packets"
+	P "git.eclipse.org/gitroot/paho.incubator/smidge.git/packets"
 )
 
 type SNClient interface {
@@ -30,7 +30,7 @@
 	Conn             *net.UDPConn
 	Address          *net.UDPAddr
 	registeredTopics map[uint16]string
-	pendingMessages  map[uint16]*PublishMessage
+	pendingMessages  map[uint16]*P.PublishMessage
 }
 
 func NewClient(ClientId string, Conn *net.UDPConn, Address *net.UDPAddr) *Client {
@@ -41,11 +41,11 @@
 		Conn,
 		Address,
 		make(map[uint16]string),
-		make(map[uint16]*PublishMessage),
+		make(map[uint16]*P.PublishMessage),
 	}
 }
 
-func (c *Client) Write(m Message) error {
+func (c *Client) Write(m P.Message) error {
 	var buf bytes.Buffer
 	m.Write(&buf)
 	_, e := c.Conn.WriteToUDP(buf.Bytes(), c.Address)
@@ -66,13 +66,13 @@
 	return ok
 }
 
-func (c *Client) AddPendingMessage(p *PublishMessage) {
+func (c *Client) AddPendingMessage(p *P.PublishMessage) {
 	defer c.Unlock()
 	c.Lock()
 	c.pendingMessages[p.TopicId] = p
 }
 
-func (c *Client) FetchPendingMessage(topicId uint16) *PublishMessage {
+func (c *Client) FetchPendingMessage(topicId uint16) *P.PublishMessage {
 	defer c.Unlock()
 	c.Lock()
 	pm := c.pendingMessages[topicId]
diff --git a/gateway/gate/transparentclient.go b/gateway/gate/transparentclient.go
index 07195c4..230ec22 100644
--- a/gateway/gate/transparentclient.go
+++ b/gateway/gate/transparentclient.go
@@ -16,7 +16,7 @@
 	"net"
 	"sync"
 
-	. "smidge/packets"
+	P "git.eclipse.org/gitroot/paho.incubator/smidge.git/packets"
 
 	MQTT "git.eclipse.org/gitroot/paho/org.eclipse.paho.mqtt.golang.git"
 )
@@ -40,7 +40,7 @@
 			Connection,
 			Address,
 			make(map[uint16]string),
-			make(map[uint16]*PublishMessage),
+			make(map[uint16]*P.PublishMessage),
 		},
 		nil,
 		Broker,
@@ -81,7 +81,7 @@
 		tid := tIndex.getId(msg.Topic())
 		// is topicid type always 0 coming out of tIndex ?
 		// todo: msgid is not always 0
-		pm := NewPublishMessage(tid, 0x00, msg.Payload(), msg.Qos(), 0x00, msg.Retained(), msg.Duplicate())
+		pm := P.NewPublishMessage(tid, 0x00, msg.Payload(), msg.Qos(), 0x00, msg.Retained(), msg.Duplicate())
 
 		if err := t.Write(pm); err != nil {
 			ERROR.Println(err)
diff --git a/gateway/gate/transparentgateway.go b/gateway/gate/transparentgateway.go
index 6bedb3b..b3f6fd4 100644
--- a/gateway/gate/transparentgateway.go
+++ b/gateway/gate/transparentgateway.go
@@ -18,7 +18,7 @@
 	"os"
 	"sync"
 
-	. "smidge/packets"
+	P "git.eclipse.org/gitroot/paho.incubator/smidge.git/packets"
 
 	//MQTT "git.eclipse.org/gitroot/paho/org.eclipse.paho.mqtt.golang.git"
 )
@@ -70,80 +70,80 @@
 	INFO.Printf("bytes: %s\n", string(buffer[0:nbytes]))
 
 	buf := bytes.NewBuffer(buffer)
-	rawmsg, _ := ReadPacket(buf)
+	rawmsg, _ := P.ReadPacket(buf)
 
-	INFO.Printf("rawmsg.MessageType(): %s\n", MessageNames[rawmsg.MessageType()])
+	INFO.Printf("rawmsg.MessageType(): %s\n", P.MessageNames[rawmsg.MessageType()])
 
 	switch msg := rawmsg.(type) {
-	case *AdvertiseMessage:
+	case *P.AdvertiseMessage:
 		t.handle_ADVERTISE(msg, addr)
-	case *SearchGwMessage:
+	case *P.SearchGwMessage:
 		t.handle_SEARCHGW(msg, addr)
-	case *GwInfoMessage:
+	case *P.GwInfoMessage:
 		t.handle_GWINFO(msg, addr)
-	case *ConnectMessage:
+	case *P.ConnectMessage:
 		t.handle_CONNECT(msg, con, addr)
-	case *ConnackMessage:
+	case *P.ConnackMessage:
 		t.handle_CONNACK(msg, addr)
-	case *WillTopicReqMessage:
+	case *P.WillTopicReqMessage:
 		t.handle_WILLTOPICREQ(msg, addr)
-	case *WillTopicMessage:
+	case *P.WillTopicMessage:
 		t.handle_WILLTOPIC(msg, addr)
-	case *WillMsgReqMessage:
+	case *P.WillMsgReqMessage:
 		t.handle_WILLMSGREQ(msg, addr)
-	case *WillMsgMessage:
+	case *P.WillMsgMessage:
 		t.handle_WILLMSG(msg, addr)
-	case *RegisterMessage:
+	case *P.RegisterMessage:
 		t.handle_REGISTER(msg, con, addr)
-	case *RegackMessage:
+	case *P.RegackMessage:
 		t.handle_REGACK(msg, addr)
-	case *PublishMessage:
+	case *P.PublishMessage:
 		t.handle_PUBLISH(msg, addr)
-	case *PubackMessage:
+	case *P.PubackMessage:
 		t.handle_PUBACK(msg, addr)
-	case *PubcompMessage:
+	case *P.PubcompMessage:
 		t.handle_PUBCOMP(msg, addr)
-	case *PubrecMessage:
+	case *P.PubrecMessage:
 		t.handle_PUBREC(msg, addr)
-	case *PubrelMessage:
+	case *P.PubrelMessage:
 		t.handle_PUBREL(msg, addr)
-	case *SubscribeMessage:
+	case *P.SubscribeMessage:
 		t.handle_SUBSCRIBE(msg, addr)
-	case *SubackMessage:
+	case *P.SubackMessage:
 		t.handle_SUBACK(msg, addr)
-	case *UnsubackMessage:
+	case *P.UnsubackMessage:
 		t.handle_UNSUBACK(msg, addr)
-	case *PingreqMessage:
+	case *P.PingreqMessage:
 		t.handle_PINGREQ(msg, con, addr)
-	case *DisconnectMessage:
+	case *P.DisconnectMessage:
 		t.handle_DISCONNECT(msg, addr)
-	case *WillTopicUpdateMessage:
+	case *P.WillTopicUpdateMessage:
 		t.handle_WILLTOPICUPD(msg, addr)
-	case *WillTopicRespMessage:
+	case *P.WillTopicRespMessage:
 		t.handle_WILLTOPICRESP(msg, addr)
-	case *WillMsgUpdateMessage:
+	case *P.WillMsgUpdateMessage:
 		t.handle_WILLMSGUPD(msg, addr)
-	case *WillMsgRespMessage:
+	case *P.WillMsgRespMessage:
 		t.handle_WILLMSGRESP(msg, addr)
 	default:
 		ERROR.Printf("Unknown Message Type %T\n", msg)
 	}
 }
 
-func (t *TGateway) handle_ADVERTISE(m *AdvertiseMessage, a *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], a)
+func (t *TGateway) handle_ADVERTISE(m *P.AdvertiseMessage, a *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], a)
 }
 
-func (t *TGateway) handle_SEARCHGW(m *SearchGwMessage, a *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], a)
+func (t *TGateway) handle_SEARCHGW(m *P.SearchGwMessage, a *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], a)
 }
 
-func (t *TGateway) handle_GWINFO(m *GwInfoMessage, a *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], a)
+func (t *TGateway) handle_GWINFO(m *P.GwInfoMessage, a *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], a)
 }
 
-func (t *TGateway) handle_CONNECT(m *ConnectMessage, c *net.UDPConn, a *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], a)
+func (t *TGateway) handle_CONNECT(m *P.ConnectMessage, c *net.UDPConn, a *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], a)
 	INFO.Println(m.ProtocolId, m.Duration, m.ClientId)
 	if clientid, err := validateClientId(m.ClientId); err != nil {
 		ERROR.Println(err)
@@ -161,7 +161,7 @@
 
 			// establish connection to mqtt broker
 
-			ca := NewMessage(CONNACK).(*ConnackMessage)
+			ca := P.NewMessage(P.CONNACK).(*P.ConnackMessage)
 			ca.ReturnCode = 0
 			if err = tClient.Write(ca); err != nil {
 				ERROR.Println(err)
@@ -172,28 +172,28 @@
 	}
 }
 
-func (t *TGateway) handle_CONNACK(m *ConnackMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_CONNACK(m *P.ConnackMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 }
 
-func (t *TGateway) handle_WILLTOPICREQ(m *WillTopicReqMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_WILLTOPICREQ(m *P.WillTopicReqMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 }
 
-func (t *TGateway) handle_WILLTOPIC(m *WillTopicMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_WILLTOPIC(m *P.WillTopicMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 }
 
-func (t *TGateway) handle_WILLMSGREQ(m *WillMsgReqMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_WILLMSGREQ(m *P.WillMsgReqMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 }
 
-func (t *TGateway) handle_WILLMSG(m *WillMsgMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_WILLMSG(m *P.WillMsgMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 }
 
-func (t *TGateway) handle_REGISTER(m *RegisterMessage, c *net.UDPConn, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_REGISTER(m *P.RegisterMessage, c *net.UDPConn, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 	topic := string(m.TopicName)
 	var topicid uint16
 	if !t.tIndex.containsTopic(topic) {
@@ -207,7 +207,7 @@
 	tclient := t.clients.GetClient(r).(*TClient)
 	tclient.Register(topicid, topic)
 
-	ra := NewRegackMessage(topicid, m.MessageId, 0)
+	ra := P.NewRegackMessage(topicid, m.MessageId, 0)
 	INFO.Printf("ra.Msgid: %d\n", ra.MessageId)
 
 	if err := tclient.Write(ra); err != nil {
@@ -217,12 +217,12 @@
 	}
 }
 
-func (t *TGateway) handle_REGACK(m *RegackMessage, a *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], a)
+func (t *TGateway) handle_REGACK(m *P.RegackMessage, a *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], a)
 }
 
-func (t *TGateway) handle_PUBLISH(m *PublishMessage, a *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], a)
+func (t *TGateway) handle_PUBLISH(m *P.PublishMessage, a *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], a)
 	tclient := t.clients.GetClient(a).(*TClient)
 
 	topic := t.tIndex.getTopic(m.TopicId)
@@ -235,24 +235,24 @@
 	INFO.Println("PUBLISH published")
 }
 
-func (t *TGateway) handle_PUBACK(m *PubackMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_PUBACK(m *P.PubackMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 }
 
-func (t *TGateway) handle_PUBCOMP(m *PubcompMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_PUBCOMP(m *P.PubcompMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 }
 
-func (t *TGateway) handle_PUBREC(m *PubrecMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_PUBREC(m *P.PubrecMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 }
 
-func (t *TGateway) handle_PUBREL(m *PubrelMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_PUBREL(m *P.PubrelMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 }
 
-func (t *TGateway) handle_SUBSCRIBE(m *SubscribeMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_SUBSCRIBE(m *P.SubscribeMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 	topic := ""
 	if m.TopicIdType == 0 { // todo: other topic id types, also use enum
 		topic = string(m.TopicName)
@@ -264,7 +264,7 @@
 	INFO.Printf("subscribe, qos: %d, topic: %s\n", m.Qos, topic)
 	tclient.subscribeMQTT(m.Qos, topic, &t.tIndex)
 
-	suba := NewSubackMessage(0, m.MessageId, m.Qos, 0)
+	suba := P.NewSubackMessage(0, m.MessageId, m.Qos, 0)
 
 	if err := tclient.Write(suba); err != nil {
 		ERROR.Println(err)
@@ -273,23 +273,23 @@
 	}
 }
 
-func (t *TGateway) handle_SUBACK(m *SubackMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_SUBACK(m *P.SubackMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 }
 
-func (t *TGateway) handle_UNSUBSCRIBE(m *UnsubscribeMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_UNSUBSCRIBE(m *P.UnsubscribeMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 }
 
-func (t *TGateway) handle_UNSUBACK(m *UnsubackMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_UNSUBACK(m *P.UnsubackMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 }
 
-func (t *TGateway) handle_PINGREQ(m *PingreqMessage, c *net.UDPConn, a *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], a)
+func (t *TGateway) handle_PINGREQ(m *P.PingreqMessage, c *net.UDPConn, a *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], a)
 	tclient := t.clients.GetClient(a).(*TClient)
 
-	resp := NewMessage(PINGRESP)
+	resp := P.NewMessage(P.PINGRESP)
 
 	if err := tclient.Write(resp); err != nil {
 		ERROR.Println(err)
@@ -298,29 +298,29 @@
 	}
 }
 
-func (t *TGateway) handle_PINGRESP(m *PingrespMessage, a *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], a)
+func (t *TGateway) handle_PINGRESP(m *P.PingrespMessage, a *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], a)
 }
 
-func (t *TGateway) handle_DISCONNECT(m *DisconnectMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_DISCONNECT(m *P.DisconnectMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 	tclient := t.clients.GetClient(r).(*TClient)
 	tclient.disconnectMQTT()
 	t.clients.RemoveClient(tclient.ClientId)
 }
 
-func (t *TGateway) handle_WILLTOPICUPD(m *WillTopicUpdateMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_WILLTOPICUPD(m *P.WillTopicUpdateMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 }
 
-func (t *TGateway) handle_WILLTOPICRESP(m *WillTopicRespMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_WILLTOPICRESP(m *P.WillTopicRespMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 }
 
-func (t *TGateway) handle_WILLMSGUPD(m *WillMsgUpdateMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_WILLMSGUPD(m *P.WillMsgUpdateMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 }
 
-func (t *TGateway) handle_WILLMSGRESP(m *WillMsgRespMessage, r *net.UDPAddr) {
-	INFO.Printf("handle_%s from %v\n", MessageNames[m.MessageType()], r)
+func (t *TGateway) handle_WILLMSGRESP(m *P.WillMsgRespMessage, r *net.UDPAddr) {
+	INFO.Printf("handle_%s from %v\n", P.MessageNames[m.MessageType()], r)
 }
diff --git a/gateway/gateway.go b/gateway/gateway.go
index fb85c06..215b205 100644
--- a/gateway/gateway.go
+++ b/gateway/gateway.go
@@ -17,7 +17,7 @@
 	"os"
 	"os/signal"
 
-	G "smidge/gateway/gate"
+	G "git.eclipse.org/gitroot/paho.incubator/smidge.git/gateway/gate"
 )
 
 func main() {