diff --git a/src/Makefile b/src/Makefile
index c90a275..073268d 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -1,11 +1,11 @@
 CPPFLAGS ?= -g -O0 -Wall `pkg-config --cflags libosmocore` `pkg-config --cflags qmi-glib`
 LIBS ?= `pkg-config --libs libosmocore` `pkg-config --libs qmi-glib`
-all: qxdm-log
+all: osmo-qcdiag-log
 
 MODS_LOG = gprs_rlc.o gprs_mac.o diag_gsm.o diag_log.o diag_log_gsm.o diag_log_gprs.o diag_log_umts.o diag_log_qmi.o
 
-qxdm-log: diagchar_hdlc.o diag_io.o qxdm-log.o diag_msg.o protocol.o $(MODS_LOG)
+osmo-qcdiag-log: diagchar_hdlc.o diag_io.o osmo-qcdiag-log.o diag_msg.o protocol.o $(MODS_LOG)
 	$(CC) $(CPPFLAGS) -o $@ $^ $(LIBS)
 
 clean:
-	@rm -f qxdm-log *.o
+	@rm -f osmo-qcdiag-log *.o
diff --git a/src/diag_gsm.c b/src/diag_gsm.c
index a2d0ea4..b05f6ca 100644
--- a/src/diag_gsm.c
+++ b/src/diag_gsm.c
@@ -1,3 +1,22 @@
+/* Utlity code for GSM related logging */
+/*
+ * (C) 2013-2016 by Harald Welte <laforge@gnumonks.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
 #include <osmocom/core/utils.h>
 #include <osmocom/core/msgb.h>
 
diff --git a/src/diag_io.c b/src/diag_io.c
index f9abd87..f4a7f88 100644
--- a/src/diag_io.c
+++ b/src/diag_io.c
@@ -1,3 +1,21 @@
+/*
+ * (C) 2013-2016 by Harald Welte <laforge@gnumonks.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
 
 #include <stdint.h>
 #include <stdio.h>
diff --git a/src/diag_log.c b/src/diag_log.c
index 2f0bc79..55cc6aa 100644
--- a/src/diag_log.c
+++ b/src/diag_log.c
@@ -1,3 +1,21 @@
+/*
+ * (C) 2013-2016 by Harald Welte <laforge@gnumonks.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
 #include <stdio.h>
 #include <string.h>
 #include <stdint.h>
diff --git a/src/diag_log_gprs.c b/src/diag_log_gprs.c
index 3225d6a..3a65ac0 100644
--- a/src/diag_log_gprs.c
+++ b/src/diag_log_gprs.c
@@ -1,3 +1,21 @@
+/*
+ * (C) 2013-2016 by Harald Welte <laforge@gnumonks.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
 #include <stdio.h>
 
 #include "diag_log.h"
diff --git a/src/diag_log_gsm.c b/src/diag_log_gsm.c
index cfc96a4..8f44169 100644
--- a/src/diag_log_gsm.c
+++ b/src/diag_log_gsm.c
@@ -1,3 +1,21 @@
+/*
+ * (C) 2013-2016 by Harald Welte <laforge@gnumonks.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
 #include <stdio.h>
 
 #include "diag_log.h"
diff --git a/src/diag_log_qmi.c b/src/diag_log_qmi.c
index cc9f0a8..bad63df 100644
--- a/src/diag_log_qmi.c
+++ b/src/diag_log_qmi.c
@@ -1,3 +1,21 @@
+/*
+ * (C) 2013-2016 by Harald Welte <laforge@gnumonks.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
 #include <stdint.h>
 #include <stdio.h>
 
diff --git a/src/diag_msg.c b/src/diag_msg.c
index b17106d..1301ad0 100644
--- a/src/diag_msg.c
+++ b/src/diag_msg.c
@@ -1,3 +1,20 @@
+/*
+ * (C) 2013-2016 by Harald Welte <laforge@gnumonks.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
 
 #include <stdlib.h>
 #include <stdio.h>
diff --git a/src/gprs_mac.c b/src/gprs_mac.c
index 79341f6..934f166 100644
--- a/src/gprs_mac.c
+++ b/src/gprs_mac.c
@@ -1,3 +1,21 @@
+/*
+ * (C) 2013-2016 by Harald Welte <laforge@gnumonks.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
 #include <osmocom/core/utils.h>
 
 #include "protocol/diag_log_gprs_mac.h"
diff --git a/src/gprs_rlc.c b/src/gprs_rlc.c
index 9e3bed0..be01a53 100644
--- a/src/gprs_rlc.c
+++ b/src/gprs_rlc.c
@@ -1,3 +1,21 @@
+/*
+ * (C) 2013-2016 by Harald Welte <laforge@gnumonks.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
 #include <osmocom/core/utils.h>
 
 #include "protocol/diag_log_gprs_rlc.h"
diff --git a/src/qxdm-log.c b/src/osmo-qcdiag-log.c
similarity index 78%
rename from src/qxdm-log.c
rename to src/osmo-qcdiag-log.c
index fceb9db..07101b0 100644
--- a/src/qxdm-log.c
+++ b/src/osmo-qcdiag-log.c
@@ -1,3 +1,24 @@
+/*
+ * (C) 2013-2016 by Harald Welte <laforge@gnumonks.org>
+ *
+ * oriiginally based on ealier code from Dieter Spaar and Holger
+ * Freyther, though by now almost entirely rewritten.  Nevertheless,
+ * thanks to Dieter and Holger!
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
 
 #include <stdlib.h>
 #include <inttypes.h>
diff --git a/src/protocol.c b/src/protocol.c
index 7574227..d9d003f 100644
--- a/src/protocol.c
+++ b/src/protocol.c
@@ -1,3 +1,21 @@
+/*
+ * (C) 2013-2016 by Harald Welte <laforge@gnumonks.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
 #include <osmocom/core/msgb.h>
 #include "protocol/protocol.h"
 #include "protocol/diagcmd.h"
