Merge commit 'ba01fa44feb6deb0f0359f381eafe866991c06c1' into pablo/namespace

48 files changed, 1323 insertions, 218 deletions

diff --git a/src/shared/libosmocore/debian/changelog b/src/shared/libosmocore/debian/changelog
index 4c103cb9..20a04938 100644
--- a/src/shared/libosmocore/debian/changelog
+++ b/src/shared/libosmocore/debian/changelog
@@ -1,3 +1,9 @@
+libosmocore (0.3.0) natty; urgency=low
+
+  * New upstream version of libosmocore
+
+ -- Harald Welte <laforge@gnumonks.org>  Tue, 10 May 2011 17:28:24 +0200
+
 libosmocore (0.1.27) natty; urgency=low
 
   * New upstream version of libosmocore.
diff --git a/src/shared/libosmocore/debian/libosmocore-dev.dirs b/src/shared/libosmocore/debian/libosmocore-dev.dirs
index e168dc66..94090a39 100644
--- a/src/shared/libosmocore/debian/libosmocore-dev.dirs
+++ b/src/shared/libosmocore/debian/libosmocore-dev.dirs
@@ -1,5 +1,8 @@
 usr/lib
 usr/include
-usr/include/osmocore
 usr/include/osmocom
+usr/include/osmocom/codec
+usr/include/osmocom/core
+usr/include/osmocom/crypt
+usr/include/osmocom/gsm
 usr/include/osmocom/vty
diff --git a/src/shared/libosmocore/debian/libosmocore.dirs b/src/shared/libosmocore/debian/libosmocore.dirs
index e168dc66..94090a39 100644
--- a/src/shared/libosmocore/debian/libosmocore.dirs
+++ b/src/shared/libosmocore/debian/libosmocore.dirs
@@ -1,5 +1,8 @@
 usr/lib
 usr/include
-usr/include/osmocore
 usr/include/osmocom
+usr/include/osmocom/codec
+usr/include/osmocom/core
+usr/include/osmocom/crypt
+usr/include/osmocom/gsm
 usr/include/osmocom/vty
diff --git a/src/shared/libosmocore/include/osmocom/core/Makefile.am b/src/shared/libosmocore/include/osmocom/core/Makefile.am
index 6109f478..36988733 100644
--- a/src/shared/libosmocore/include/osmocom/core/Makefile.am
+++ b/src/shared/libosmocore/include/osmocom/core/Makefile.am
@@ -3,7 +3,7 @@ osmocore_HEADERS = signal.h linuxlist.h timer.h select.h msgb.h bits.h \
 		   gsmtap.h write_queue.h \
 		   logging.h rate_ctr.h gsmtap_util.h \
 		   plugin.h crc16.h panic.h process.h msgfile.h \
-		   backtrace.h
+		   backtrace.h conv.h application.h
 
 if ENABLE_TALLOC
 osmocore_HEADERS += talloc.h
diff --git a/src/shared/libosmocore/include/osmocom/core/application.h b/src/shared/libosmocore/include/osmocom/core/application.h
new file mode 100644
index 00000000..c1642ec4
--- /dev/null
+++ b/src/shared/libosmocore/include/osmocom/core/application.h
@@ -0,0 +1,16 @@
+#ifndef OSMO_APPLICATION_H
+#define OSMO_APPLICATION_H
+
+/**
+ * Routines for helping with the application setup.
+ */
+
+struct log_info;
+struct log_target;
+
+extern struct log_target *osmo_stderr_target;
+
+void osmo_init_ignore_signals(void);
+int osmo_init_logging(const struct log_info *);
+
+#endif
diff --git a/src/shared/libosmocore/include/osmocom/core/backtrace.h b/src/shared/libosmocore/include/osmocom/core/backtrace.h
index bbbb2c28..5a8a8161 100644
--- a/src/shared/libosmocore/include/osmocom/core/backtrace.h
+++ b/src/shared/libosmocore/include/osmocom/core/backtrace.h
@@ -1,6 +1,6 @@
 #ifndef _OSMO_BACKTRACE_H_
 #define _OSMO_BACKTRACE_H_
 
-void generate_backtrace();
+void osmo_generate_backtrace();
 
 #endif
diff --git a/src/shared/libosmocore/include/osmocom/core/conv.h b/src/shared/libosmocore/include/osmocom/core/conv.h
new file mode 100644
index 00000000..af676eed
--- /dev/null
+++ b/src/shared/libosmocore/include/osmocom/core/conv.h
@@ -0,0 +1,101 @@
+/*
+ * conv.h
+ *
+ * Copyright (C) 2011  Sylvain Munaut <tnt@246tNt.com>
+ *
+ * All Rights Reserved
+ *
+ * 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.
+ */
+
+#ifndef __OSMO_CONV_H__
+#define __OSMO_CONV_H__
+
+#include <stdint.h>
+
+#include <osmocom/core/bits.h>
+
+struct osmo_conv_code {
+	int N;
+	int K;
+	int len;
+
+	const uint8_t (*next_output)[2];
+	const uint8_t (*next_state)[2];
+
+	const uint8_t *next_term_output;
+	const uint8_t *next_term_state;
+
+	const int *puncture;
+};
+
+
+/* Encoding */
+
+	/* Low level API */
+struct osmo_conv_encoder {
+	const struct osmo_conv_code *code;
+	int i_idx;	/* Next input bit index */
+	int p_idx;	/* Current puncture index */
+	uint8_t state;	/* Current state */
+};
+
+void osmo_conv_encode_init(struct osmo_conv_encoder *encoder,
+                           const struct osmo_conv_code *code);
+int  osmo_conv_encode_raw(struct osmo_conv_encoder *encoder,
+                          const ubit_t *input, ubit_t *output, int n);
+int  osmo_conv_encode_finish(struct osmo_conv_encoder *encoder, ubit_t *output);
+
+	/* All-in-one */
+int  osmo_conv_encode(const struct osmo_conv_code *code,
+                      const ubit_t *input, ubit_t *output);
+
+
+/* Decoding */
+
+	/* Low level API */
+struct osmo_conv_decoder {
+	const struct osmo_conv_code *code;
+
+	int n_states;
+
+	int len;		/* Max o_idx (excl. termination) */
+
+	int o_idx;		/* output index */
+	int p_idx;		/* puncture index */
+
+	unsigned int *ae;	/* accumulater error */
+	unsigned int *ae_next;	/* next accumulated error (tmp in scan) */
+	uint8_t *state_history;	/* state history [len][n_states] */
+};
+
+void osmo_conv_decode_init(struct osmo_conv_decoder *decoder,
+                           const struct osmo_conv_code *code, int len);
+void osmo_conv_decode_reset(struct osmo_conv_decoder *decoder);
+void osmo_conv_decode_deinit(struct osmo_conv_decoder *decoder);
+
+int osmo_conv_decode_scan(struct osmo_conv_decoder *decoder,
+                          const sbit_t *input, int n);
+int osmo_conv_decode_finish(struct osmo_conv_decoder *decoder,
+                            const sbit_t *input);
+int osmo_conv_decode_get_output(struct osmo_conv_decoder *decoder,
+                                ubit_t *output, int has_finish);
+
+	/* All-in-one */
+int osmo_conv_decode(const struct osmo_conv_code *code,
+                     const sbit_t *input, ubit_t *output);
+
+
+#endif /* __OSMO_CONV_H__ */
diff --git a/src/shared/libosmocore/include/osmocom/core/crc16.h b/src/shared/libosmocore/include/osmocom/core/crc16.h
index 7a512490..0e524176 100644
--- a/src/shared/libosmocore/include/osmocom/core/crc16.h
+++ b/src/shared/libosmocore/include/osmocom/core/crc16.h
@@ -22,13 +22,13 @@
 
 #include <sys/types.h>
 
-extern uint16_t const crc16_table[256];
+extern uint16_t const osmo_crc16_table[256];
 
-extern uint16_t crc16(uint16_t crc, const uint8_t *buffer, size_t len);
+extern uint16_t osmo_crc16(uint16_t crc, const uint8_t *buffer, size_t len);
 
-static inline uint16_t crc16_byte(uint16_t crc, const uint8_t data)
+static inline uint16_t osmo_crc16_byte(uint16_t crc, const uint8_t data)
 {
-	return (crc >> 8) ^ crc16_table[(crc ^ data) & 0xff];
+	return (crc >> 8) ^ osmo_crc16_table[(crc ^ data) & 0xff];
 }
 
 #endif /* __CRC16_H */
diff --git a/src/shared/libosmocore/include/osmocom/core/gsmtap_util.h b/src/shared/libosmocore/include/osmocom/core/gsmtap_util.h
index 96449443..785f5e58 100644
--- a/src/shared/libosmocore/include/osmocom/core/gsmtap_util.h
+++ b/src/shared/libosmocore/include/osmocom/core/gsmtap_util.h
@@ -18,4 +18,8 @@ int gsmtap_sendmsg(uint16_t arfcn, uint8_t ts, uint8_t chan_type, uint8_t ss,
 
 int gsmtap_init(uint32_t dst_ip);
 
+/* Create a local 'gsmtap sink' avoiding the UDP packets being rejected
+ * with ICMP reject messages */
+int gsmtap_sink_init(uint32_t bind_ip);
+
 #endif /* _GSMTAP_UTIL_H */
diff --git a/src/shared/libosmocore/include/osmocom/core/msgb.h b/src/shared/libosmocore/include/osmocom/core/msgb.h
index 57b5d7f4..8665c2bf 100644
--- a/src/shared/libosmocore/include/osmocom/core/msgb.h
+++ b/src/shared/libosmocore/include/osmocom/core/msgb.h
@@ -181,7 +181,7 @@ static inline void msgb_reserve(struct msgb *msg, int len)
 static inline struct msgb *msgb_alloc_headroom(int size, int headroom,
 						const char *name)
 {
-	static_assert(size > headroom, headroom_bigger);
+	osmo_static_assert(size > headroom, headroom_bigger);
 
 	struct msgb *msg = msgb_alloc(size, name);
 	if (msg)
diff --git a/src/shared/libosmocore/include/osmocom/core/msgfile.h b/src/shared/libosmocore/include/osmocom/core/msgfile.h
index 92caa9fc..c5e67a45 100644
--- a/src/shared/libosmocore/include/osmocom/core/msgfile.h
+++ b/src/shared/libosmocore/include/osmocom/core/msgfile.h
@@ -22,12 +22,12 @@
 #ifndef MSG_FILE_H
 #define MSG_FILE_H
 
-#include "linuxlist.h"
+#include <osmocom/core/linuxlist.h>
 
 /**
  * One message in the list.
  */
-struct msg_entry {
+struct osmo_config_entry {
 	struct llist_head list;
 
 	/* number for everyone to use */
@@ -40,10 +40,10 @@ struct msg_entry {
 	char *text;
 };
 
-struct msg_entries {
+struct osmo_config_list {
 	struct llist_head entry;
 };
 
-struct msg_entries *msg_entry_parse(void *ctx, const char *filename);
+struct osmo_config_list* osmo_config_list_parse(void *ctx, const char *filename);
 
 #endif
diff --git a/src/shared/libosmocore/include/osmocom/core/panic.h b/src/shared/libosmocore/include/osmocom/core/panic.h
index c5a83778..c28a8440 100644
--- a/src/shared/libosmocore/include/osmocom/core/panic.h
+++ b/src/shared/libosmocore/include/osmocom/core/panic.h
@@ -5,7 +5,7 @@
 
 typedef void (*osmo_panic_handler_t)(const char *fmt, va_list args);
 
-void osmo_panic(const char *fmt, ...);
-void osmo_set_panic_handler(osmo_panic_handler_t h);
+extern void osmo_panic(const char *fmt, ...);
+extern void osmo_set_panic_handler(osmo_panic_handler_t h);
 
 #endif
diff --git a/src/shared/libosmocore/include/osmocom/core/plugin.h b/src/shared/libosmocore/include/osmocom/core/plugin.h
index 98f9b56d..6c0eccc6 100644
--- a/src/shared/libosmocore/include/osmocom/core/plugin.h
+++ b/src/shared/libosmocore/include/osmocom/core/plugin.h
@@ -1,6 +1,6 @@
 #ifndef _OSMO_PLUGIN_H
 #define _OSMO_PLUGIN_H
 
-int plugin_load_all(const char *directory);
+int osmo_plugin_load_all(const char *directory);
 
 #endif
diff --git a/src/shared/libosmocore/include/osmocom/core/select.h b/src/shared/libosmocore/include/osmocom/core/select.h
index 5ca21c3e..476c564e 100644
--- a/src/shared/libosmocore/include/osmocom/core/select.h
+++ b/src/shared/libosmocore/include/osmocom/core/select.h
@@ -7,16 +7,16 @@
 #define BSC_FD_WRITE	0x0002
 #define BSC_FD_EXCEPT	0x0004
 
-struct bsc_fd {
+struct osmo_fd {
 	struct llist_head list;
 	int fd;
 	unsigned int when;
-	int (*cb)(struct bsc_fd *fd, unsigned int what);
+	int (*cb)(struct osmo_fd *fd, unsigned int what);
 	void *data;
 	unsigned int priv_nr;
 };
 
-int bsc_register_fd(struct bsc_fd *fd);
-void bsc_unregister_fd(struct bsc_fd *fd);
-int bsc_select_main(int polling);
+int osmo_fd_register(struct osmo_fd *fd);
+void osmo_fd_unregister(struct osmo_fd *fd);
+int osmo_select_main(int polling);
 #endif /* _BSC_SELECT_H */
diff --git a/src/shared/libosmocore/include/osmocom/core/signal.h b/src/shared/libosmocore/include/osmocom/core/signal.h
index 02d83d2e..535fd185 100644
--- a/src/shared/libosmocore/include/osmocom/core/signal.h
+++ b/src/shared/libosmocore/include/osmocom/core/signal.h
@@ -1,15 +1,14 @@
-#ifndef OSMOCORE_SIGNAL_H
-#define OSMOCORE_SIGNAL_H
+#ifndef OSMO_SIGNAL_H
+#define OSMO_SIGNAL_H
 
-typedef int signal_cbfn(unsigned int subsys, unsigned int signal,
-			void *handler_data, void *signal_data);
+typedef int osmo_signal_cbfn(unsigned int subsys, unsigned int signal, void *handler_data, void *signal_data);
 
 
 /* Management */
-int register_signal_handler(unsigned int subsys, signal_cbfn *cbfn, void *data);
-void unregister_signal_handler(unsigned int subsys, signal_cbfn *cbfn, void *data);
+int osmo_signal_register_handler(unsigned int subsys, osmo_signal_cbfn *cbfn, void *data);
+void osmo_signal_unregister_handler(unsigned int subsys, osmo_signal_cbfn *cbfn, void *data);
 
 /* Dispatch */
-void dispatch_signal(unsigned int subsys, unsigned int signal, void *signal_data);
+void osmo_signal_dispatch(unsigned int subsys, unsigned int signal, void *signal_data);
 
-#endif /* OSMOCORE_SIGNAL_H */
+#endif /* OSMO_SIGNAL_H */
diff --git a/src/shared/libosmocore/include/osmocom/core/statistics.h b/src/shared/libosmocore/include/osmocom/core/statistics.h
index 2c159657..18493277 100644
--- a/src/shared/libosmocore/include/osmocom/core/statistics.h
+++ b/src/shared/libosmocore/include/osmocom/core/statistics.h
@@ -1,33 +1,33 @@
 #ifndef _STATISTICS_H
 #define _STATISTICS_H
 
-struct counter {
+struct osmo_counter {
 	struct llist_head list;
 	const char *name;
 	const char *description;
 	unsigned long value;
 };
 
-static inline void counter_inc(struct counter *ctr)
+static inline void osmo_counter_inc(struct osmo_counter *ctr)
 {
 	ctr->value++;
 }
 
-static inline unsigned long counter_get(struct counter *ctr)
+static inline unsigned long osmo_counter_get(struct osmo_counter *ctr)
 {
 	return ctr->value;
 }
 
-static inline void counter_reset(struct counter *ctr)
+static inline void osmo_counter_reset(struct osmo_counter *ctr)
 {
 	ctr->value = 0;
 }
 
-struct counter *counter_alloc(const char *name);
-void counter_free(struct counter *ctr);
+struct osmo_counter *osmo_counter_alloc(const char *name);
+void osmo_counter_free(struct osmo_counter *ctr);
 
-int counters_for_each(int (*handle_counter)(struct counter *, void *), void *data);
+int osmo_counters_for_each(int (*handle_counter)(struct osmo_counter *, void *), void *data);
 
-struct counter *counter_get_by_name(const char *name);
+struct osmo_counter *osmo_counter_get_by_name(const char *name);
 
 #endif /* _STATISTICS_H */
diff --git a/src/shared/libosmocore/include/osmocom/core/timer.h b/src/shared/libosmocore/include/osmocom/core/timer.h
index 19664781..db2ecbf7 100644
--- a/src/shared/libosmocore/include/osmocom/core/timer.h
+++ b/src/shared/libosmocore/include/osmocom/core/timer.h
@@ -27,7 +27,7 @@
 
 /**
  * Timer management:
- *      - Create a struct timer_list
+ *      - Create a struct osmo_timer_list
  *      - Fill out timeout and use add_timer or
  *        use schedule_timer to schedule a timer in
  *        x seconds and microseconds from now...
@@ -41,7 +41,7 @@
  *        the timers.
  *
  */
-struct timer_list {
+struct osmo_timer_list {
 	struct llist_head entry;
 	struct timeval timeout;
 	unsigned int active  : 1;
@@ -55,18 +55,18 @@ struct timer_list {
 /**
  * timer management
  */
-void bsc_add_timer(struct timer_list *timer);
-void bsc_schedule_timer(struct timer_list *timer, int seconds, int microseconds);
-void bsc_del_timer(struct timer_list *timer);
-int bsc_timer_pending(struct timer_list *timer);
+void osmo_timer_add(struct osmo_timer_list *timer);
+void osmo_timer_schedule(struct osmo_timer_list *timer, int seconds, int microseconds);
+void osmo_timer_del(struct osmo_timer_list *timer);
+int osmo_timer_pending(struct osmo_timer_list *timer);
 
 
 /**
  * internal timer list management
  */
-struct timeval *bsc_nearest_timer();
-void bsc_prepare_timers();
-int bsc_update_timers();
-int bsc_timer_check(void);
+struct timeval *osmo_timers_nearest();
+void osmo_timers_prepare();
+int osmo_timers_update();
+int osmo_timers_check(void);
 
 #endif
diff --git a/src/shared/libosmocore/include/osmocom/core/utils.h b/src/shared/libosmocore/include/osmocom/core/utils.h
index 252228de..0f1ea3bb 100644
--- a/src/shared/libosmocore/include/osmocom/core/utils.h
+++ b/src/shared/libosmocore/include/osmocom/core/utils.h
@@ -13,16 +13,16 @@ struct value_string {
 const char *get_value_string(const struct value_string *vs, uint32_t val);
 int get_string_value(const struct value_string *vs, const char *str);
 
-char bcd2char(uint8_t bcd);
+char osmo_bcd2char(uint8_t bcd);
 /* only works for numbers in ascci */
-uint8_t char2bcd(char c);
+uint8_t osmo_char2bcd(char c);
 
-int hexparse(const char *str, uint8_t *b, int max_len);
-char *hexdump(const unsigned char *buf, int len);
-char *hexdump_nospc(const unsigned char *buf, int len);
-char *ubit_dump(const uint8_t *bits, unsigned int len);
+int osmo_hexparse(const char *str, uint8_t *b, int max_len);
+char *osmo_hexdump(const unsigned char *buf, int len);
+char *osmo_osmo_hexdump_nospc(const unsigned char *buf, int len);
+char *osmo_ubit_dump(const uint8_t *bits, unsigned int len);
 
-#define static_assert(exp, name) typedef int dummy##name [(exp) ? 1 : -1];
+#define osmo_static_assert(exp, name) typedef int dummy##name [(exp) ? 1 : -1];
 
 void osmo_str2lower(char *out, const char *in);
 void osmo_str2upper(char *out, const char *in);
diff --git a/src/shared/libosmocore/include/osmocom/core/write_queue.h b/src/shared/libosmocore/include/osmocom/core/write_queue.h
index 3b730c77..41748d72 100644
--- a/src/shared/libosmocore/include/osmocom/core/write_queue.h
+++ b/src/shared/libosmocore/include/osmocom/core/write_queue.h
@@ -20,27 +20,27 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  */
-#ifndef write_queue_h
-#define write_queue_h
+#ifndef OSMO_WQUEUE_H
+#define OSMO_WQUEUE_H
 
 #include <osmocom/core/select.h>
 #include <osmocom/core/msgb.h>
 
-struct write_queue {
-	struct bsc_fd bfd;
+struct osmo_wqueue {
+	struct osmo_fd bfd;
 	unsigned int max_length;
 	unsigned int current_length;
 
 	struct llist_head msg_queue;
 
-	int (*read_cb)(struct bsc_fd *fd);
-	int (*write_cb)(struct bsc_fd *fd, struct msgb *msg);
-	int (*except_cb)(struct bsc_fd *fd);
+	int (*read_cb)(struct osmo_fd *fd);
+	int (*write_cb)(struct osmo_fd *fd, struct msgb *msg);
+	int (*except_cb)(struct osmo_fd *fd);
 };
 
-void write_queue_init(struct write_queue *queue, int max_length);
-void write_queue_clear(struct write_queue *queue);
-int write_queue_enqueue(struct write_queue *queue, struct msgb *data);
-int write_queue_bfd_cb(struct bsc_fd *fd, unsigned int what);
+void osmo_wqueue_init(struct osmo_wqueue *queue, int max_length);
+void osmo_wqueue_clear(struct osmo_wqueue *queue);
+int osmo_wqueue_enqueue(struct osmo_wqueue *queue, struct msgb *data);
+int osmo_wqueue_bfd_cb(struct osmo_fd *fd, unsigned int what);
 
 #endif
diff --git a/src/shared/libosmocore/include/osmocom/gsm/Makefile.am b/src/shared/libosmocore/include/osmocom/gsm/Makefile.am
index 8685fc9a..a39d2d04 100644
--- a/src/shared/libosmocore/include/osmocom/gsm/Makefile.am
+++ b/src/shared/libosmocore/include/osmocom/gsm/Makefile.am
@@ -1,4 +1,4 @@
-osmogsm_HEADERS = comp128.h gsm0808.h gsm48_ie.h mncc.h rxlev_stat.h \
+osmogsm_HEADERS = a5.h comp128.h gsm0808.h gsm48_ie.h mncc.h rxlev_stat.h \
 		  gsm0480.h gsm48.h gsm_utils.h rsl.h tlv.h
 
 SUBDIRS = protocol
diff --git a/src/shared/libosmocore/include/osmocom/gsm/a5.h b/src/shared/libosmocore/include/osmocom/gsm/a5.h
new file mode 100644
index 00000000..2c630e5f
--- /dev/null
+++ b/src/shared/libosmocore/include/osmocom/gsm/a5.h
@@ -0,0 +1,49 @@
+/*
+ * a5.h
+ *
+ * Copyright (C) 2011  Sylvain Munaut <tnt@246tNt.com>
+ *
+ * All Rights Reserved
+ *
+ * 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.
+ */
+
+#ifndef __OSMO_A5_H__
+#define __OSMO_A5_H__
+
+#include <stdint.h>
+
+#include <osmocom/core/bits.h>
+
+static inline uint32_t
+osmo_a5_fn_count(uint32_t fn)
+{
+	int t1 = fn / (26 * 51);
+	int t2 = fn % 26;
+	int t3 = fn % 51;
+	return (t1 << 11) | (t3 << 5) | t2;
+}
+
+	/* Notes:
+	 *  - key must be 8 bytes long (or NULL for A5/0)
+	 *  - the dl and ul pointer must be either NULL or 114 bits long
+	 *  - fn is the _real_ GSM frame number.
+	 *    (converted internally to fn_count)
+	 */
+void osmo_a5(int n, uint8_t *key, uint32_t fn, ubit_t *dl, ubit_t *ul);
+void osmo_a5_1(uint8_t *key, uint32_t fn, ubit_t *dl, ubit_t *ul);
+void osmo_a5_2(uint8_t *key, uint32_t fn, ubit_t *dl, ubit_t *ul);
+
+#endif /* __OSMO_A5_H__ */
diff --git a/src/shared/libosmocore/include/osmocom/vty/telnet_interface.h b/src/shared/libosmocore/include/osmocom/vty/telnet_interface.h
index 0c034e41..1d8055e7 100644
--- a/src/shared/libosmocore/include/osmocom/vty/telnet_interface.h
+++ b/src/shared/libosmocore/include/osmocom/vty/telnet_interface.h
@@ -29,7 +29,7 @@
 struct telnet_connection {
 	struct llist_head entry;
 	void *priv;
-	struct bsc_fd fd;
+	struct osmo_fd fd;
 	struct vty *vty;
 	struct log_target *dbg;
 };
diff --git a/src/shared/libosmocore/src/Makefile.am b/src/shared/libosmocore/src/Makefile.am
index c5c8a21d..e58bc286 100644
--- a/src/shared/libosmocore/src/Makefile.am
+++ b/src/shared/libosmocore/src/Makefile.am
@@ -2,7 +2,7 @@ SUBDIRS=. vty codec gsm
 
 # This is _NOT_ the library release version, it's an API version.
 # Please read Chapter 6 "Library interface versions" of the libtool documentation before making any modification
-LIBVERSION=0:0:0
+LIBVERSION=1:0:1
 
 INCLUDES = $(all_includes) -I$(top_srcdir)/include
 AM_CFLAGS = -fPIC -Wall
@@ -14,11 +14,13 @@ libosmocore_la_SOURCES = timer.c select.c signal.c msgb.c bits.c \
 			 write_queue.c utils.c \
 			 logging.c logging_syslog.c rate_ctr.c \
 			 gsmtap_util.c crc16.c panic.c backtrace.c \
-			 process.c
+			 process.c conv.c application.c
 
 if ENABLE_PLUGIN
 libosmocore_la_SOURCES += plugin.c
-libosmocore_la_LDFLAGS = -ldl
+libosmocore_la_LDFLAGS = -version-info $(LIBVERSION) -ldl
+else
+libosmocore_la_LDFLAGS = -version-info $(LIBVERSION)
 endif
 
 if ENABLE_TALLOC
diff --git a/src/shared/libosmocore/src/application.c b/src/shared/libosmocore/src/application.c
new file mode 100644
index 00000000..96b4204e
--- /dev/null
+++ b/src/shared/libosmocore/src/application.c
@@ -0,0 +1,49 @@
+/* Utility functions to setup applications */
+/*
+ * (C) 2011 by Holger Hans Peter Freyther
+ *
+ * All Rights Reserved
+ *
+ * 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/application.h>
+#include <osmocom/core/logging.h>
+
+#include <signal.h>
+
+struct log_target *osmo_stderr_target;
+
+void osmo_init_ignore_signals(void)
+{
+	/* Signals that by default would terminate */
+	signal(SIGPIPE, SIG_IGN);
+	signal(SIGALRM, SIG_IGN);
+	signal(SIGHUP, SIG_IGN);
+	signal(SIGIO, SIG_IGN);
+}
+
+int osmo_init_logging(const struct log_info *log_info)
+{
+	log_init(log_info);
+	osmo_stderr_target = log_target_create_stderr();
+	if (!osmo_stderr_target)
+		return -1;
+
+	log_add_target(osmo_stderr_target);
+	log_set_all_filter(osmo_stderr_target, 1);
+	return 0;
+}
diff --git a/src/shared/libosmocore/src/backtrace.c b/src/shared/libosmocore/src/backtrace.c
index ecd6b9c5..8281fada 100644
--- a/src/shared/libosmocore/src/backtrace.c
+++ b/src/shared/libosmocore/src/backtrace.c
@@ -29,7 +29,7 @@
 
 #ifdef HAVE_EXECINFO_H
 #include <execinfo.h>
-void generate_backtrace()
+void osmo_generate_backtrace()
 {
 	int i, nptrs;
 	void *buffer[100];
diff --git a/src/shared/libosmocore/src/codec/Makefile.am b/src/shared/libosmocore/src/codec/Makefile.am
index f8a06012..5a54c42d 100644
--- a/src/shared/libosmocore/src/codec/Makefile.am
+++ b/src/shared/libosmocore/src/codec/Makefile.am
@@ -8,3 +8,4 @@ AM_CFLAGS = -fPIC -Wall
 lib_LTLIBRARIES = libosmocodec.la
 
 libosmocodec_la_SOURCES = gsm610.c gsm620.c gsm660.c gsm690.c
+libosmocodec_la_LDFALGS = -version-info $(LIBVERSION)
diff --git a/src/shared/libosmocore/src/conv.c b/src/shared/libosmocore/src/conv.c
new file mode 100644
index 00000000..70bdffba
--- /dev/null
+++ b/src/shared/libosmocore/src/conv.c
@@ -0,0 +1,496 @@
+/*
+ * conv.c
+ *
+ * Generic convolutional encoding / decoding
+ *
+ * Copyright (C) 2011  Sylvain Munaut <tnt@246tNt.com>
+ *
+ * All Rights Reserved
+ *
+ * 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 <alloca.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <osmocom/core/bits.h>
+#include <osmocom/core/conv.h>
+
+
+/* ------------------------------------------------------------------------ */
+/* Encoding                                                                 */
+/* ------------------------------------------------------------------------ */
+
+void
+osmo_conv_encode_init(struct osmo_conv_encoder *encoder,
+                      const struct osmo_conv_code *code)
+{
+	memset(encoder, 0x00, sizeof(struct osmo_conv_encoder));
+	encoder->code = code;
+}
+
+static inline int
+_conv_encode_do_output(struct osmo_conv_encoder *encoder,
+                       uint8_t out, ubit_t *output)
+{
+	const struct osmo_conv_code *code = encoder->code;
+	int o_idx = 0;
+	int j;
+
+	if (code->puncture) {
+		for (j=0; j<code->N; j++)
+		{
+			int bit_no = code->N - j - 1;
+			int r_idx = encoder->i_idx * code->N + j;
+
+			if (code->puncture[encoder->p_idx] == r_idx)
+				encoder->p_idx++;
+			else
+				output[o_idx++] = (out >> bit_no) & 1;
+		}
+	} else {
+		for (j=0; j<code->N; j++)
+		{
+			int bit_no = code->N - j - 1;
+			output[o_idx++] = (out >> bit_no) & 1;
+		}
+	}
+
+	return o_idx;
+}
+
+int
+osmo_conv_encode_raw(struct osmo_conv_encoder *encoder,
+                     const ubit_t *input, ubit_t *output, int n)
+{
+	const struct osmo_conv_code *code = encoder->code;
+	uint8_t state;
+	int i;
+	int o_idx;
+
+	o_idx = 0;
+	state = encoder->state;
+
+	for (i=0; i<n; i++) {
+		int bit = input[i];
+		uint8_t out;
+
+		out   = code->next_output[state][bit];
+		state = code->next_state[state][bit];
+
+		o_idx += _conv_encode_do_output(encoder, out, &output[o_idx]);
+
+		encoder->i_idx++;
+	}
+
+	encoder->state = state;
+
+	return o_idx;
+}
+
+int
+osmo_conv_encode_finish(struct osmo_conv_encoder *encoder,
+                        ubit_t *output)
+{
+	const struct osmo_conv_code *code = encoder->code;
+	uint8_t state;
+	int n;
+	int i;
+	int o_idx;
+
+	n = code->K - 1;
+
+	o_idx = 0;
+	state = encoder->state;
+
+	for (i=0; i<n; i++) {
+		uint8_t out;
+
+		if (code->next_term_output) {
+			out   = code->next_term_output[state];
+			state = code->next_term_state[state];
+		} else {
+			out   = code->next_output[state][0];
+			state = code->next_state[state][0];
+		}
+
+		o_idx += _conv_encode_do_output(encoder, out, &output[o_idx]);
+
+		encoder->i_idx++;
+	}
+
+	encoder->state = state;
+
+	return o_idx;
+}
+
+int
+osmo_conv_encode(const struct osmo_conv_code *code,
+                 const ubit_t *input, ubit_t *output)
+{
+	struct osmo_conv_encoder encoder;
+	int l;
+
+	osmo_conv_encode_init(&encoder, code);
+	l  = osmo_conv_encode_raw(&encoder, input, output, code->len);
+	l += osmo_conv_encode_finish(&encoder, &output[l]);
+
+	return l;
+}
+
+
+/* ------------------------------------------------------------------------ */
+/* Decoding (viterbi)                                                       */
+/* ------------------------------------------------------------------------ */
+
+#define MAX_AE 0x00ffffff
+
+void
+osmo_conv_decode_init(struct osmo_conv_decoder *decoder,
+                      const struct osmo_conv_code *code, int len)
+{
+	int n_states;
+
+	/* Init */
+	if (len <= 0)
+		len =  code->len;
+
+	n_states = 1 << (code->K - 1);
+
+	memset(decoder, 0x00, sizeof(struct osmo_conv_decoder));
+
+	decoder->code = code;
+	decoder->n_states = n_states;
+	decoder->len = len;
+
+	/* Allocate arrays */
+	decoder->ae      = malloc(sizeof(unsigned int) * n_states);
+	decoder->ae_next = malloc(sizeof(unsigned int) * n_states);
+
+	decoder->state_history = malloc(sizeof(uint8_t) * n_states * (len + decoder->code->K - 1));
+
+	/* Classic reset */
+	osmo_conv_decode_reset(decoder);
+}
+
+void
+osmo_conv_decode_reset(struct osmo_conv_decoder *decoder)
+{
+	int i;
+
+	/* Reset indexes */
+	decoder->o_idx = 0;
+	decoder->p_idx = 0;
+
+	/* Initial error (only state 0 is valid) */
+	decoder->ae[0] = 0;
+	for (i=1; i<decoder->n_states; i++) {
+		decoder->ae[i] = MAX_AE;
+	}
+}
+
+void
+osmo_conv_decode_deinit(struct osmo_conv_decoder *decoder)
+{
+	free(decoder->ae);
+	free(decoder->ae_next);
+	free(decoder->state_history);
+
+	memset(decoder, 0x00, sizeof(struct osmo_conv_decoder));
+}
+
+int
+osmo_conv_decode_scan(struct osmo_conv_decoder *decoder,
+                      const sbit_t *input, int n)
+{
+	const struct osmo_conv_code *code = decoder->code;
+
+	int i, s, b, j;
+
+	int n_states;
+	unsigned int *ae;
+	unsigned int *ae_next;
+	uint8_t *state_history;
+	sbit_t *in_sym;
+
+	int i_idx, p_idx;
+
+	/* Prepare */
+	n_states = decoder->n_states;
+
+	ae      = decoder->ae;
+	ae_next = decoder->ae_next;
+	state_history = &decoder->state_history[n_states * decoder->o_idx];
+
+	in_sym  = alloca(sizeof(sbit_t) * code->N);
+
+	i_idx = 0;
+	p_idx = decoder->p_idx;
+
+	/* Scan the treillis */
+	for (i=0; i<n; i++)
+	{
+		/* Reset next accumulated error */
+		for (s=0; s<n_states; s++) {
+			ae_next[s] = MAX_AE;
+		}
+
+		/* Get input */
+		if (code->puncture) {
+			/* Hard way ... */
+			for (j=0; j<code->N; j++) {
+				int idx = ((decoder->o_idx + i) * code->N) + j;
+				if (idx == code->puncture[p_idx]) {
+					in_sym[j] = 0;	/* Undefined */
+					p_idx++;
+				} else {
+					in_sym[j] = input[i_idx];
+					i_idx++;
+				}
+			}
+		} else {
+			/* Easy, just copy N bits */
+			memcpy(in_sym, &input[i_idx], code->N);
+			i_idx += code->N;
+		}
+
+		/* Scan all state */
+		for (s=0; s<n_states; s++)
+		{
+			/* Scan possible input bits */
+			for (b=0; b<2; b++)
+			{
+				int nae, ov, e;
+				uint8_t m;
+
+				/* Next output and state */
+				uint8_t out   = code->next_output[s][b];
+				uint8_t state = code->next_state[s][b];
+
+				/* New error for this path */
+				nae = ae[s];			/* start from last error */
+				m = 1 << (code->N - 1);		/* mask for 'out' bit selection */
+
+				for (j=0; j<code->N; j++) {
+					ov = (out & m) ? -127 : 127; /* sbit_t value for it */
+					e = ((int)in_sym[j]) - ov;   /* raw error for this bit */
+					nae += (e * e) >> 9;         /* acc the squared/scaled value */
+					m >>= 1;                     /* next mask bit */
+				}
+
+				/* Is it survivor ? */
+				if (ae_next[state] > nae) {
+					ae_next[state] = nae;
+					state_history[(n_states * i) + state] = s;
+				}
+			}
+		}
+
+		/* Copy accumulated error */
+		memcpy(ae, ae_next, sizeof(unsigned int) * n_states);
+	}
+
+	/* Update decoder state */
+	decoder->p_idx = p_idx;
+	decoder->o_idx += n;
+
+	return i_idx;
+}
+
+int
+osmo_conv_decode_finish(struct osmo_conv_decoder *decoder,
+                        const sbit_t *input)
+{
+	const struct osmo_conv_code *code = decoder->code;
+
+	int i, s, j;
+
+	int n_states;
+	unsigned int *ae;
+	unsigned int *ae_next;
+	uint8_t *state_history;
+	sbit_t *in_sym;
+
+	int i_idx, p_idx;
+
+	/* Prepare */
+	n_states = decoder->n_states;
+
+	ae      = decoder->ae;
+	ae_next = decoder->ae_next;
+	state_history = &decoder->state_history[n_states * decoder->o_idx];
+
+	in_sym  = alloca(sizeof(sbit_t) * code->N);
+
+	i_idx = 0;
+	p_idx = decoder->p_idx;
+
+	/* Scan the treillis */
+	for (i=0; i<code->K-1; i++)
+	{
+		/* Reset next accumulated error */
+		for (s=0; s<n_states; s++) {
+			ae_next[s] = MAX_AE;
+		}
+
+		/* Get input */
+		if (code->puncture) {
+			/* Hard way ... */
+			for (j=0; j<code->N; j++) {
+				int idx = ((decoder->o_idx + i) * code->N) + j;
+				if (idx == code->puncture[p_idx]) {
+					in_sym[j] = 0;	/* Undefined */
+					p_idx++;
+				} else {
+					in_sym[j] = input[i_idx];
+					i_idx++;
+				}
+			}
+		} else {
+			/* Easy, just copy N bits */
+			memcpy(in_sym, &input[i_idx], code->N);
+			i_idx += code->N;
+		}
+
+		/* Scan all state */
+		for (s=0; s<n_states; s++)
+		{
+			int nae, ov, e;
+			uint8_t m;
+
+			/* Next output and state */
+			uint8_t out;
+			uint8_t state;
+
+			if (code->next_term_output) {
+				out   = code->next_term_output[s];
+				state = code->next_term_state[s];
+			} else {
+				out   = code->next_output[s][0];
+				state = code->next_state[s][0];
+			}
+
+			/* New error for this path */
+			nae = ae[s];			/* start from last error */
+			m = 1 << (code->N - 1);		/* mask for 'out' bit selection */
+
+			for (j=0; j<code->N; j++) {
+				int is = (int)in_sym[j];
+				if (is) {
+					ov = (out & m) ? -127 : 127; /* sbit_t value for it */
+					e = is - ov;                 /* raw error for this bit */
+					nae += (e * e) >> 9;         /* acc the squared/scaled value */
+				}
+				m >>= 1;                     /* next mask bit */
+			}
+
+			/* Is it survivor ? */
+			if (ae_next[state] > nae) {
+				ae_next[state] = nae;
+				state_history[(n_states * i) + state] = s;
+			}
+		}
+
+		/* Copy accumulated error */
+		memcpy(ae, ae_next, sizeof(unsigned int) * n_states);
+	}
+
+	/* Update decoder state */
+	decoder->p_idx = p_idx;
+	decoder->o_idx += code->K - 1;
+
+	return i_idx;
+}
+
+int
+osmo_conv_decode_get_output(struct osmo_conv_decoder *decoder,
+                            ubit_t *output, int has_finish)
+{
+	const struct osmo_conv_code *code = decoder->code;
+
+	int min_ae;
+	uint8_t min_state, cur_state;
+	int i, s, n;
+
+	uint8_t *sh_ptr;
+
+	/* Find state with least error */
+	min_ae = MAX_AE;
+	min_state = 0xff;
+
+	for (s=0; s<decoder->n_states; s++)
+	{
+		if (decoder->ae[s] < min_ae) {
+			min_ae = decoder->ae[s];
+			min_state = s;
+		}
+	}
+
+	if (min_state == 0xff)
+		return -1;
+
+	/* Traceback */
+	cur_state = min_state;
+
+	n = decoder->o_idx;
+
+	sh_ptr = &decoder->state_history[decoder->n_states * (n-1)];
+
+		/* No output for the K-1 termination input bits */
+	if (has_finish) {
+		for (i=0; i<code->K-1; i++) {
+			cur_state = sh_ptr[cur_state];
+			sh_ptr -= decoder->n_states;
+		}
+		n -= code->K - 1;
+	}
+
+		/* Generate output backward */
+	for (i=n-1; i>=0; i--)
+	{
+		min_state = cur_state;
+		cur_state = sh_ptr[cur_state];
+
+		sh_ptr -= decoder->n_states;
+
+		if (code->next_state[cur_state][0] == min_state)
+			output[i] = 0;
+		else
+			output[i] = 1;
+	}
+
+	return min_ae;
+}
+
+int
+osmo_conv_decode(const struct osmo_conv_code *code,
+                 const sbit_t *input, ubit_t *output)
+{
+	struct osmo_conv_decoder decoder;
+	int rv, l;
+
+	osmo_conv_decode_init(&decoder, code, 0);
+
+	l = osmo_conv_decode_scan(&decoder, input, code->len);
+	l = osmo_conv_decode_finish(&decoder, &input[l]);
+
+	rv = osmo_conv_decode_get_output(&decoder, output, 1);
+
+	osmo_conv_decode_deinit(&decoder);
+
+	return rv;
+}
diff --git a/src/shared/libosmocore/src/crc16.c b/src/shared/libosmocore/src/crc16.c
index 3a0d0ddb..2741cf53 100644
--- a/src/shared/libosmocore/src/crc16.c
+++ b/src/shared/libosmocore/src/crc16.c
@@ -11,7 +11,7 @@
 #include <osmocom/core/crc16.h>
 
 /** CRC table for the CRC-16. The poly is 0x8005 (x^16 + x^15 + x^2 + 1) */
-uint16_t const crc16_table[256] = {
+uint16_t const osmo_crc16_table[256] = {
 	0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
 	0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
 	0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
@@ -54,9 +54,9 @@ uint16_t const crc16_table[256] = {
  *
  * Returns the updated CRC value.
  */
-uint16_t crc16(uint16_t crc, uint8_t const *buffer, size_t len)
+uint16_t osmo_crc16(uint16_t crc, uint8_t const *buffer, size_t len)
 {
 	while (len--)
-		crc = crc16_byte(crc, *buffer++);
+		crc = osmo_crc16_byte(crc, *buffer++);
 	return crc;
 }
diff --git a/src/shared/libosmocore/src/gsm/Makefile.am b/src/shared/libosmocore/src/gsm/Makefile.am
index a8c2e569..fb4a8cb2 100644
--- a/src/shared/libosmocore/src/gsm/Makefile.am
+++ b/src/shared/libosmocore/src/gsm/Makefile.am
@@ -7,7 +7,8 @@ AM_CFLAGS = -fPIC -Wall
 
 lib_LTLIBRARIES = libosmogsm.la
 
-libosmogsm_la_SOURCES = rxlev_stat.c tlv_parser.c comp128.c gsm_utils.c \
+libosmogsm_la_SOURCES = a5.c rxlev_stat.c tlv_parser.c comp128.c gsm_utils.c \
                         rsl.c gsm48.c gsm48_ie.c gsm0808.c \
 			gprs_cipher_core.c gsm0480.c
+libosmogsm_la_LDFLAGS = -version-info $(LIBVERSION)
 libosmogsm_la_LIBADD = $(top_builddir)/src/libosmocore.la
diff --git a/src/shared/libosmocore/src/gsm/a5.c b/src/shared/libosmocore/src/gsm/a5.c
new file mode 100644
index 00000000..d3f2b2c3
--- /dev/null
+++ b/src/shared/libosmocore/src/gsm/a5.c
@@ -0,0 +1,311 @@
+/*
+ * a5.c
+ *
+ * Full reimplementation of A5/1,2 (split and threadsafe)
+ *
+ * The logic behind the algorithm is taken from "A pedagogical implementation
+ * of the GSM A5/1 and A5/2 "voice privacy" encryption algorithms." by
+ * Marc Briceno, Ian Goldberg, and David Wagner.
+ *
+ * Copyright (C) 2011  Sylvain Munaut <tnt@246tNt.com>
+ *
+ * All Rights Reserved
+ *
+ * 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 <string.h>
+
+#include <osmocom/gsm/a5.h>
+
+void
+osmo_a5(int n, uint8_t *key, uint32_t fn, ubit_t *dl, ubit_t *ul)
+{
+	switch (n)
+	{
+	case 0:
+		if (dl)
+			memset(dl, 0x00, 114);
+		if (ul)
+			memset(ul, 0x00, 114);
+		break;
+
+	case 1:
+		osmo_a5_1(key, fn, dl, ul);
+		break;
+
+	case 2:
+		osmo_a5_2(key, fn, dl, ul);
+		break;
+
+	default:
+		/* a5/[3..7] not supported here/yet */
+		break;
+	}
+}
+
+
+/* ------------------------------------------------------------------------ */
+/* A5/1&2 common stuff                                                                     */
+/* ------------------------------------------------------------------------ */
+
+#define A5_R1_LEN	19
+#define A5_R2_LEN	22
+#define A5_R3_LEN	23
+#define A5_R4_LEN	17	/* A5/2 only */
+
+#define A5_R1_MASK	((1<<A5_R1_LEN)-1)
+#define A5_R2_MASK	((1<<A5_R2_LEN)-1)
+#define A5_R3_MASK	((1<<A5_R3_LEN)-1)
+#define A5_R4_MASK	((1<<A5_R4_LEN)-1)
+
+#define A5_R1_TAPS	0x072000 /* x^19 + x^5 + x^2 + x + 1 */
+#define A5_R2_TAPS	0x300000 /* x^22 + x + 1 */
+#define A5_R3_TAPS	0x700080 /* x^23 + x^15 + x^2 + x + 1 */
+#define A5_R4_TAPS	0x010800 /* x^17 + x^5 + 1 */
+
+static inline uint32_t
+_a5_12_parity(uint32_t x)
+{
+	x ^= x >> 16;
+	x ^= x >> 8;
+	x ^= x >> 4;
+	x ^= x >> 2;
+	x ^= x >> 1;
+	return x & 1;
+}
+
+static inline uint32_t
+_a5_12_majority(uint32_t v1, uint32_t v2, uint32_t v3)
+{
+	return (!!v1 + !!v2 + !!v3) >= 2;
+}
+
+static inline uint32_t
+_a5_12_clock(uint32_t r, uint32_t mask, uint32_t taps)
+{
+	return ((r << 1) & mask) | _a5_12_parity(r & taps);
+}
+
+
+/* ------------------------------------------------------------------------ */
+/* A5/1                                                                     */
+/* ------------------------------------------------------------------------ */
+
+#define A51_R1_CLKBIT	0x000100
+#define A51_R2_CLKBIT	0x000400
+#define A51_R3_CLKBIT	0x000400
+
+static inline void
+_a5_1_clock(uint32_t r[], int force)
+{
+	int cb[3], maj;
+
+	cb[0] = !!(r[0] & A51_R1_CLKBIT);
+	cb[1] = !!(r[1] & A51_R2_CLKBIT);
+	cb[2] = !!(r[2] & A51_R3_CLKBIT);
+
+	maj = _a5_12_majority(cb[0], cb[1], cb[2]);
+
+	if (force || (maj == cb[0]))
+		r[0] = _a5_12_clock(r[0], A5_R1_MASK, A5_R1_TAPS);
+
+	if (force || (maj == cb[1]))
+		r[1] = _a5_12_clock(r[1], A5_R2_MASK, A5_R2_TAPS);
+
+	if (force || (maj == cb[2]))
+		r[2] = _a5_12_clock(r[2], A5_R3_MASK, A5_R3_TAPS);
+}
+
+static inline uint8_t
+_a5_1_get_output(uint32_t r[])
+{
+	return	(r[0] >> (A5_R1_LEN-1)) ^
+		(r[1] >> (A5_R2_LEN-1)) ^
+		(r[2] >> (A5_R3_LEN-1));
+}
+
+void
+osmo_a5_1(uint8_t *key, uint32_t fn, ubit_t *dl, ubit_t *ul)
+{
+	uint32_t r[3] = {0, 0, 0};
+	uint32_t fn_count;
+	uint32_t b;
+	int i;
+
+	/* Key load */
+	for (i=0; i<64; i++)
+	{
+		b = ( key[7 - (i>>3)] >> (i&7) ) & 1;
+
+		_a5_1_clock(r, 1);
+
+		r[0] ^= b;
+		r[1] ^= b;
+		r[2] ^= b;
+	}
+
+	/* Frame count load */
+	fn_count = osmo_a5_fn_count(fn);
+
+	for (i=0; i<22; i++)
+	{
+		b = (fn_count >> i) & 1;
+
+		_a5_1_clock(r, 1);
+
+		r[0] ^= b;
+		r[1] ^= b;
+		r[2] ^= b;
+	}
+
+	/* Mix */
+	for (i=0; i<100; i++)
+	{
+		_a5_1_clock(r, 0);
+	}
+
+	/* Output */
+	for (i=0; i<114; i++) {
+		_a5_1_clock(r, 0);
+		if (dl)
+			dl[i] = _a5_1_get_output(r);
+	}
+
+	for (i=0; i<114; i++) {
+		_a5_1_clock(r, 0);
+		if (ul)
+			ul[i] = _a5_1_get_output(r);
+	}
+}
+
+
+/* ------------------------------------------------------------------------ */
+/* A5/2                                                                     */
+/* ------------------------------------------------------------------------ */
+
+#define A52_R4_CLKBIT0	0x000400
+#define A52_R4_CLKBIT1	0x000008
+#define A52_R4_CLKBIT2	0x000080
+
+static inline void
+_a5_2_clock(uint32_t r[], int force)
+{
+	int cb[3], maj;
+
+	cb[0] = !!(r[3] & A52_R4_CLKBIT0);
+	cb[1] = !!(r[3] & A52_R4_CLKBIT1);
+	cb[2] = !!(r[3] & A52_R4_CLKBIT2);
+
+	maj = (cb[0] + cb[1] + cb[2]) >= 2;
+
+	if (force || (maj == cb[0]))
+		r[0] = _a5_12_clock(r[0], A5_R1_MASK, A5_R1_TAPS);
+
+	if (force || (maj == cb[1]))
+		r[1] = _a5_12_clock(r[1], A5_R2_MASK, A5_R2_TAPS);
+
+	if (force || (maj == cb[2]))
+		r[2] = _a5_12_clock(r[2], A5_R3_MASK, A5_R3_TAPS);
+
+	r[3] = _a5_12_clock(r[3], A5_R4_MASK, A5_R4_TAPS);
+}
+
+static inline uint8_t
+_a5_2_get_output(uint32_t r[], uint8_t *db)
+{
+	uint8_t cb, tb;
+
+	tb =	(r[0] >> (A5_R1_LEN-1)) ^
+		(r[1] >> (A5_R2_LEN-1)) ^
+		(r[2] >> (A5_R3_LEN-1));
+
+	cb = *db;
+
+	*db = (	tb ^
+		_a5_12_majority( r[0] & 0x08000, ~r[0] & 0x04000,  r[0] & 0x1000) ^
+		_a5_12_majority(~r[1] & 0x10000,  r[1] & 0x02000,  r[1] & 0x0200) ^
+		_a5_12_majority( r[2] & 0x40000,  r[2] & 0x10000, ~r[2] & 0x2000)
+	);
+
+	return cb;
+}
+
+void
+osmo_a5_2(uint8_t *key, uint32_t fn, ubit_t *dl, ubit_t *ul)
+{
+	uint32_t r[4] = {0, 0, 0, 0};
+	uint32_t fn_count;
+	uint32_t b;
+	uint8_t db = 0, o;
+	int i;
+
+	/* Key load */
+	for (i=0; i<64; i++)
+	{
+		b = ( key[7 - (i>>3)] >> (i&7) ) & 1;
+
+		_a5_2_clock(r, 1);
+
+		r[0] ^= b;
+		r[1] ^= b;
+		r[2] ^= b;
+		r[3] ^= b;
+	}
+
+	/* Frame count load */
+	fn_count = osmo_a5_fn_count(fn);
+
+	for (i=0; i<22; i++)
+	{
+		b = (fn_count >> i) & 1;
+
+		_a5_2_clock(r, 1);
+
+		r[0] ^= b;
+		r[1] ^= b;
+		r[2] ^= b;
+		r[3] ^= b;
+	}
+
+	r[0] |= 1 << 15;
+	r[1] |= 1 << 16;
+	r[2] |= 1 << 18;
+	r[3] |= 1 << 10;
+
+	/* Mix */
+	for (i=0; i<100; i++)
+	{
+		_a5_2_clock(r, 0);
+	}
+
+	_a5_2_get_output(r, &db);
+
+
+	/* Output */
+	for (i=0; i<114; i++) {
+		_a5_2_clock(r, 0);
+		o = _a5_2_get_output(r, &db);
+		if (dl)
+			dl[i] = o;
+	}
+
+	for (i=0; i<114; i++) {
+		_a5_2_clock(r, 0);
+		o = _a5_2_get_output(r, &db);
+		if (ul)
+			ul[i] = o;
+	}
+}
diff --git a/src/shared/libosmocore/src/gsm/gprs_cipher_core.c b/src/shared/libosmocore/src/gsm/gprs_cipher_core.c
index 0ff85e2d..7884be01 100644
--- a/src/shared/libosmocore/src/gsm/gprs_cipher_core.c
+++ b/src/shared/libosmocore/src/gsm/gprs_cipher_core.c
@@ -53,7 +53,7 @@ int gprs_cipher_register(struct gprs_cipher_impl *ciph)
 int gprs_cipher_load(const char *path)
 {
 	/* load all plugins available from path */
-	return plugin_load_all(path);
+	return osmo_plugin_load_all(path);
 }
 
 /* function to be called by core code */
diff --git a/src/shared/libosmocore/src/gsm/gsm48.c b/src/shared/libosmocore/src/gsm/gsm48.c
index 436bf14b..d0345892 100644
--- a/src/shared/libosmocore/src/gsm/gsm48.c
+++ b/src/shared/libosmocore/src/gsm/gsm48.c
@@ -301,7 +301,7 @@ int gsm48_generate_mid_from_imsi(uint8_t *buf, const char *imsi)
 	uint8_t odd = (length & 0x1) == 1;
 
 	buf[0] = GSM48_IE_MOBILE_ID;
-	buf[2] = char2bcd(imsi[0]) << 4 | GSM_MI_TYPE_IMSI | (odd << 3);
+	buf[2] = osmo_char2bcd(imsi[0]) << 4 | GSM_MI_TYPE_IMSI | (odd << 3);
 
 	/* if the length is even we will fill half of the last octet */
 	if (odd)
@@ -312,11 +312,11 @@ int gsm48_generate_mid_from_imsi(uint8_t *buf, const char *imsi)
 	for (i = 1; i < buf[1]; ++i) {
 		uint8_t lower, upper;
 
-		lower = char2bcd(imsi[++off]);
+		lower = osmo_char2bcd(imsi[++off]);
 		if (!odd && off + 1 == length)
 			upper = 0x0f;
 		else
-			upper = char2bcd(imsi[++off]) & 0x0f;
+			upper = osmo_char2bcd(imsi[++off]) & 0x0f;
 
 		buf[2 + i] = (upper << 4) | lower;
 	}
@@ -349,15 +349,15 @@ int gsm48_mi_to_string(char *string, const int str_len, const uint8_t *mi,
 	case GSM_MI_TYPE_IMSI:
 	case GSM_MI_TYPE_IMEI:
 	case GSM_MI_TYPE_IMEISV:
-		*str_cur++ = bcd2char(mi[0] >> 4);
+		*str_cur++ = osmo_bcd2char(mi[0] >> 4);
 
                 for (i = 1; i < mi_len; i++) {
 			if (str_cur + 2 >= string + str_len)
 				return str_cur - string;
-			*str_cur++ = bcd2char(mi[i] & 0xf);
+			*str_cur++ = osmo_bcd2char(mi[i] & 0xf);
 			/* skip last nibble in last input byte when GSM_EVEN */
 			if( (i != mi_len-1) || (mi[0] & GSM_MI_ODD))
-				*str_cur++ = bcd2char(mi[i] >> 4);
+				*str_cur++ = osmo_bcd2char(mi[i] >> 4);
 		}
 		break;
 	default:
diff --git a/src/shared/libosmocore/src/gsmtap_util.c b/src/shared/libosmocore/src/gsmtap_util.c
index 6d02d58f..e0bc848c 100644
--- a/src/shared/libosmocore/src/gsmtap_util.c
+++ b/src/shared/libosmocore/src/gsmtap_util.c
@@ -42,7 +42,8 @@
 #include <string.h>
 #include <errno.h>
 
-static struct bsc_fd gsmtap_bfd = { .fd = -1 };
+static struct osmo_fd gsmtap_bfd = { .fd = -1 };
+static struct osmo_fd gsmtap_sink_bfd = { .fd = -1 };
 static LLIST_HEAD(gsmtap_txqueue);
 
 uint8_t chantype_rsl2gsmtap(uint8_t rsl_chantype, uint8_t link_id)
@@ -136,7 +137,7 @@ int gsmtap_sendmsg(uint16_t arfcn, uint8_t ts, uint8_t chan_type, uint8_t ss,
 }
 
 /* Callback from select layer if we can write to the socket */
-static int gsmtap_fd_cb(struct bsc_fd *fd, unsigned int flags)
+static int gsmtap_fd_cb(struct osmo_fd *fd, unsigned int flags)
 {
 	struct msgb *msg;
 	int rc;
@@ -175,7 +176,7 @@ int gsmtap_init(uint32_t dst_ip)
 	sin.sin_port = htons(GSMTAP_UDP_PORT);
 	sin.sin_addr.s_addr = htonl(dst_ip);
 
-	/* FIXME: create socket */
+	/* create socket */
 	rc = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 	if (rc < 0) {
 		perror("creating UDP socket");
@@ -186,7 +187,7 @@ int gsmtap_init(uint32_t dst_ip)
 	if (rc < 0) {
 		perror("connecting UDP socket");
 		close(gsmtap_bfd.fd);
-		gsmtap_bfd.fd = 0;
+		gsmtap_bfd.fd = -1;
 		return rc;
 	}
 
@@ -194,7 +195,59 @@ int gsmtap_init(uint32_t dst_ip)
 	gsmtap_bfd.cb = gsmtap_fd_cb;
 	gsmtap_bfd.data = NULL;
 
-	return bsc_register_fd(&gsmtap_bfd);
+	return osmo_fd_register(&gsmtap_bfd);
+}
+
+/* Callback from select layer if we can read from the sink socket */
+static int gsmtap_sink_fd_cb(struct osmo_fd *fd, unsigned int flags)
+{
+	int rc;
+	uint8_t buf[4096];
+
+	if (!(flags & BSC_FD_READ))
+		return 0;
+
+	rc = read(fd->fd, buf, sizeof(buf));
+	if (rc < 0) {
+		perror("reading from gsmtap sink fd");
+		return rc;
+	}
+	/* simply discard any data arriving on the socket */
+
+	return 0;
+}
+
+/* Create a local 'gsmtap sink' avoiding the UDP packets being rejected
+ * with ICMP reject messages */
+int gsmtap_sink_init(uint32_t bind_ip)
+{
+	int rc;
+	struct sockaddr_in sin;
+
+	sin.sin_family = AF_INET;
+	sin.sin_port = htons(GSMTAP_UDP_PORT);
+	sin.sin_addr.s_addr = htonl(bind_ip);
+
+	rc = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+	if (rc < 0) {
+		perror("creating UDP socket");
+		return rc;
+	}
+	gsmtap_sink_bfd.fd = rc;
+	rc = bind(rc, (struct sockaddr *)&sin, sizeof(sin));
+	if (rc < 0) {
+		perror("binding UDP socket");
+		close(gsmtap_sink_bfd.fd);
+		gsmtap_sink_bfd.fd = -1;
+		return rc;
+	}
+
+	gsmtap_sink_bfd.when = BSC_FD_READ;
+	gsmtap_sink_bfd.cb = gsmtap_sink_fd_cb;
+	gsmtap_sink_bfd.data = NULL;
+
+	return osmo_fd_register(&gsmtap_sink_bfd);
+
 }
 
 #endif /* HAVE_SYS_SELECT_H */
diff --git a/src/shared/libosmocore/src/logging.c b/src/shared/libosmocore/src/logging.c
index 77c8a50d..0911010a 100644
--- a/src/shared/libosmocore/src/logging.c
+++ b/src/shared/libosmocore/src/logging.c
@@ -143,29 +143,19 @@ static void _output(struct log_target *target, unsigned int subsys,
 		    unsigned int level, char *file, int line, int cont,
 		    const char *format, va_list ap)
 {
-	char col[30];
-	char sub[30];
-	char tim[30];
 	char buf[4096];
-	char final[4096];
-
-	/* prepare the data */
-	col[0] = '\0';
-	sub[0] = '\0';
-	tim[0] = '\0';
-	buf[0] = '\0';
+	int ret, len = 0, offset = 0, rem = sizeof(buf);
 
 	/* are we using color */
 	if (target->use_color) {
 		const char *c = color(subsys);
 		if (c) {
-			snprintf(col, sizeof(col), "%s", color(subsys));
-			col[sizeof(col)-1] = '\0';
+			ret = snprintf(buf + offset, rem, "%s", color(subsys));
+			if (ret < 0)
+				goto err;
+			OSMO_SNPRINTF_RET(ret, rem, offset, len);
 		}
 	}
-	vsnprintf(buf, sizeof(buf), format, ap);
-	buf[sizeof(buf)-1] = '\0';
-
 	if (!cont) {
 		if (target->print_timestamp) {
 			char *timestr;
@@ -173,17 +163,30 @@ static void _output(struct log_target *target, unsigned int subsys,
 			tm = time(NULL);
 			timestr = ctime(&tm);
 			timestr[strlen(timestr)-1] = '\0';
-			snprintf(tim, sizeof(tim), "%s ", timestr);
-			tim[sizeof(tim)-1] = '\0';
+			ret = snprintf(buf + offset, rem, "%s ", timestr);
+			if (ret < 0)
+				goto err;
+			OSMO_SNPRINTF_RET(ret, rem, offset, len);
 		}
-		snprintf(sub, sizeof(sub), "<%4.4x> %s:%d ", subsys, file, line);
-		sub[sizeof(sub)-1] = '\0';
+		ret = snprintf(buf + offset, rem, "<%4.4x> %s:%d ",
+				subsys, file, line);
+		if (ret < 0)
+			goto err;
+		OSMO_SNPRINTF_RET(ret, rem, offset, len);
 	}
+	ret = vsnprintf(buf + offset, rem, format, ap);
+	if (ret < 0)
+		goto err;
+	OSMO_SNPRINTF_RET(ret, rem, offset, len);
 
-	snprintf(final, sizeof(final), "%s%s%s%s%s", col, tim, sub, buf,
-		 target->use_color ? "\033[0;m" : "");
-	final[sizeof(final)-1] = '\0';
-	target->output(target, level, final);
+	ret = snprintf(buf + offset, rem, "%s",
+			target->use_color ? "\033[0;m" : "");
+	if (ret < 0)
+		goto err;
+	OSMO_SNPRINTF_RET(ret, rem, offset, len);
+err:
+	buf[sizeof(buf)-1] = '\0';
+	target->output(target, level, buf);
 }
 
 
@@ -218,19 +221,10 @@ static void _logp(unsigned int subsys, int level, char *file, int line,
 		else if (osmo_log_info->filter_fn)
 			output = osmo_log_info->filter_fn(&log_context,
 						       tar);
+		if (!output)
+			continue;
 
-		if (output) {
-			/* FIXME: copying the va_list is an ugly
-			 * workaround against a bug hidden somewhere in
-			 * _output.  If we do not copy here, the first
-			 * call to _output() will corrupt the va_list
-			 * contents, and any further _output() calls
-			 * with the same va_list will segfault */
-			va_list bp;
-			va_copy(bp, ap);
-			_output(tar, subsys, level, file, line, cont, format, bp);
-			va_end(bp);
-		}
+		_output(tar, subsys, level, file, line, cont, format, ap);
 	}
 }
 
@@ -448,7 +442,7 @@ const char *log_vty_command_string(const struct log_info *info)
 		size += strlen(loglevel_strs[i].str) + 1;
 
 	rem = size;
-	str = talloc_zero_size(NULL, size);
+	str = talloc_zero_size(tall_log_ctx, size);
 	if (!str)
 		return NULL;
 
@@ -499,6 +493,7 @@ const char *log_vty_command_string(const struct log_info *info)
 		goto err;
 	OSMO_SNPRINTF_RET(ret, rem, offset, len);
 err:
+	str[size-1] = '\0';
 	return str;
 }
 
@@ -517,8 +512,9 @@ const char *log_vty_command_description(const struct log_info *info)
 	for (i = 0; i < LOGLEVEL_DEFS; i++)
 		size += strlen(loglevel_descriptions[i]) + 1;
 
+	size += strlen("Global setting for all subsystems") + 1;
 	rem = size;
-	str = talloc_zero_size(NULL, size);
+	str = talloc_zero_size(tall_log_ctx, size);
 	if (!str)
 		return NULL;
 
@@ -528,6 +524,12 @@ const char *log_vty_command_description(const struct log_info *info)
 		goto err;
 	OSMO_SNPRINTF_RET(ret, rem, offset, len);
 
+	ret = snprintf(str + offset, rem,
+			"Global setting for all subsystems\n");
+	if (ret < 0)
+		goto err;
+	OSMO_SNPRINTF_RET(ret, rem, offset, len);
+
 	for (i = 0; i < info->num_cat; i++) {
 		ret = snprintf(str + offset, rem, "%s\n",
 				info->cat[i].description);
@@ -543,6 +545,7 @@ const char *log_vty_command_description(const struct log_info *info)
 		OSMO_SNPRINTF_RET(ret, rem, offset, len);
 	}
 err:
+	str[size-1] = '\0';
 	return str;
 }
 
diff --git a/src/shared/libosmocore/src/msgfile.c b/src/shared/libosmocore/src/msgfile.c
index c13df51d..d2b180d7 100644
--- a/src/shared/libosmocore/src/msgfile.c
+++ b/src/shared/libosmocore/src/msgfile.c
@@ -29,11 +29,13 @@
 #include <unistd.h>
 #include <string.h>
 
-static struct msg_entry *alloc_entry(struct msg_entries *entries,
-				     const char *mcc, const char *mnc,
-				     const char *option, const char *text)
+static struct osmo_config_entry *
+alloc_entry(struct osmo_config_list *entries,
+	    const char *mcc, const char *mnc,
+	    const char *option, const char *text)
 {
-	struct msg_entry *entry = talloc_zero(entries, struct msg_entry);
+	struct osmo_config_entry *entry =
+		talloc_zero(entries, struct osmo_config_entry);
 	if (!entry)
 		return NULL;
 
@@ -46,11 +48,11 @@ static struct msg_entry *alloc_entry(struct msg_entries *entries,
 	return entry;
 }
 
-static struct msg_entries *alloc_entries(void *ctx)
+static struct osmo_config_list *alloc_entries(void *ctx)
 {
-	struct msg_entries *entries;
+	struct osmo_config_list *entries;
 
-	entries = talloc_zero(ctx, struct msg_entries);
+	entries = talloc_zero(ctx, struct osmo_config_list);
 	if (!entries)
 		return NULL;
 
@@ -61,7 +63,7 @@ static struct msg_entries *alloc_entries(void *ctx)
 /*
  * split a line like 'foo:Text'.
  */
-static void handle_line(struct msg_entries *entries, char *line)
+static void handle_line(struct osmo_config_list *entries, char *line)
 {
 	int i;
 	const int len = strlen(line);
@@ -91,9 +93,9 @@ static void handle_line(struct msg_entries *entries, char *line)
 	/* nothing found */
 }
 
-struct msg_entries *msg_entry_parse(void *ctx, const char *filename)
+struct osmo_config_list *osmo_config_list_parse(void *ctx, const char *filename)
 {
-	struct msg_entries *entries;
+	struct osmo_config_list *entries;
 	size_t n;
 	char *line;
 	FILE *file;
diff --git a/src/shared/libosmocore/src/panic.c b/src/shared/libosmocore/src/panic.c
index 588a5fe0..d4452264 100644
--- a/src/shared/libosmocore/src/panic.c
+++ b/src/shared/libosmocore/src/panic.c
@@ -38,7 +38,7 @@ static osmo_panic_handler_t osmo_panic_handler = (void*)0;
 static void osmo_panic_default(const char *fmt, va_list args)
 {
 	vfprintf(stderr, fmt, args);
-	generate_backtrace();
+	osmo_generate_backtrace();
 	abort();
 }
 
diff --git a/src/shared/libosmocore/src/plugin.c b/src/shared/libosmocore/src/plugin.c
index 4d9fd314..998bca35 100644
--- a/src/shared/libosmocore/src/plugin.c
+++ b/src/shared/libosmocore/src/plugin.c
@@ -32,7 +32,7 @@
 
 #include <osmocom/core/plugin.h>
 
-int plugin_load_all(const char *directory)
+int osmo_plugin_load_all(const char *directory)
 {
 	unsigned int num = 0;
 	char fname[PATH_MAX];
@@ -55,7 +55,7 @@ int plugin_load_all(const char *directory)
 	return num;
 }
 #else
-int plugin_load_all(const char *directory)
+int osmo_plugin_load_all(const char *directory)
 {
 	return 0;
 }
diff --git a/src/shared/libosmocore/src/rate_ctr.c b/src/shared/libosmocore/src/rate_ctr.c
index a0e18148..6d771a44 100644
--- a/src/shared/libosmocore/src/rate_ctr.c
+++ b/src/shared/libosmocore/src/rate_ctr.c
@@ -82,7 +82,7 @@ static void interval_expired(struct rate_ctr *ctr, enum rate_ctr_intv intv)
 		ctr->intv[intv+1].rate += ctr->intv[intv].rate;
 }
 
-static struct timer_list rate_ctr_timer;
+static struct osmo_timer_list rate_ctr_timer;
 static uint64_t timer_ticks;
 
 /* The one-second interval has expired */
@@ -114,14 +114,14 @@ static void rate_ctr_timer_cb(void *data)
 	llist_for_each_entry(ctrg, &rate_ctr_groups, list)
 		rate_ctr_group_intv(ctrg);
 
-	bsc_schedule_timer(&rate_ctr_timer, 1, 0);
+	osmo_timer_schedule(&rate_ctr_timer, 1, 0);
 }
 
 int rate_ctr_init(void *tall_ctx)
 {
 	tall_rate_ctr_ctx = tall_ctx;
 	rate_ctr_timer.cb = rate_ctr_timer_cb;
-	bsc_schedule_timer(&rate_ctr_timer, 1, 0);
+	osmo_timer_schedule(&rate_ctr_timer, 1, 0);
 
 	return 0;
 }
diff --git a/src/shared/libosmocore/src/select.c b/src/shared/libosmocore/src/select.c
index adf36194..4ea95362 100644
--- a/src/shared/libosmocore/src/select.c
+++ b/src/shared/libosmocore/src/select.c
@@ -31,10 +31,10 @@
 #ifdef HAVE_SYS_SELECT_H
 
 static int maxfd = 0;
-static LLIST_HEAD(bsc_fds);
+static LLIST_HEAD(osmo_fds);
 static int unregistered_count;
 
-int bsc_register_fd(struct bsc_fd *fd)
+int osmo_fd_register(struct osmo_fd *fd)
 {
 	int flags;
 
@@ -52,29 +52,29 @@ int bsc_register_fd(struct bsc_fd *fd)
 		maxfd = fd->fd;
 
 #ifdef BSC_FD_CHECK
-	struct bsc_fd *entry;
-	llist_for_each_entry(entry, &bsc_fds, list) {
+	struct osmo_fd *entry;
+	llist_for_each_entry(entry, &osmo_fds, list) {
 		if (entry == fd) {
-			fprintf(stderr, "Adding a bsc_fd that is already in the list.\n");
+			fprintf(stderr, "Adding a osmo_fd that is already in the list.\n");
 			return 0;
 		}
 	}
 #endif
 
-	llist_add_tail(&fd->list, &bsc_fds);
+	llist_add_tail(&fd->list, &osmo_fds);
 
 	return 0;
 }
 
-void bsc_unregister_fd(struct bsc_fd *fd)
+void osmo_fd_unregister(struct osmo_fd *fd)
 {
 	unregistered_count++;
 	llist_del(&fd->list);
 }
 
-int bsc_select_main(int polling)
+int osmo_select_main(int polling)
 {
-	struct bsc_fd *ufd, *tmp;
+	struct osmo_fd *ufd, *tmp;
 	fd_set readset, writeset, exceptset;
 	int work = 0, rc;
 	struct timeval no_time = {0, 0};
@@ -84,7 +84,7 @@ int bsc_select_main(int polling)
 	FD_ZERO(&exceptset);
 
 	/* prepare read and write fdsets */
-	llist_for_each_entry(ufd, &bsc_fds, list) {
+	llist_for_each_entry(ufd, &osmo_fds, list) {
 		if (ufd->when & BSC_FD_READ)
 			FD_SET(ufd->fd, &readset);
 
@@ -95,21 +95,21 @@ int bsc_select_main(int polling)
 			FD_SET(ufd->fd, &exceptset);
 	}
 
-	bsc_timer_check();
+	osmo_timers_check();
 
 	if (!polling)
-		bsc_prepare_timers();
-	rc = select(maxfd+1, &readset, &writeset, &exceptset, polling ? &no_time : bsc_nearest_timer());
+		osmo_timers_prepare();
+	rc = select(maxfd+1, &readset, &writeset, &exceptset, polling ? &no_time : osmo_timers_nearest());
 	if (rc < 0)
 		return 0;
 
 	/* fire timers */
-	bsc_update_timers();
+	osmo_timers_update();
 
 	/* call registered callback functions */
 restart:
 	unregistered_count = 0;
-	llist_for_each_entry_safe(ufd, tmp, &bsc_fds, list) {
+	llist_for_each_entry_safe(ufd, tmp, &osmo_fds, list) {
 		int flags = 0;
 
 		if (FD_ISSET(ufd->fd, &readset)) {
diff --git a/src/shared/libosmocore/src/signal.c b/src/shared/libosmocore/src/signal.c
index bb5c38e1..bc339bb9 100644
--- a/src/shared/libosmocore/src/signal.c
+++ b/src/shared/libosmocore/src/signal.c
@@ -31,12 +31,13 @@ static LLIST_HEAD(signal_handler_list);
 struct signal_handler {
 	struct llist_head entry;
 	unsigned int subsys;
-	signal_cbfn *cbfn;
+	osmo_signal_cbfn *cbfn;
 	void *data;
 };
 
 
-int register_signal_handler(unsigned int subsys, signal_cbfn *cbfn, void *data)
+int osmo_signal_register_handler(unsigned int subsys,
+				 osmo_signal_cbfn *cbfn, void *data)
 {
 	struct signal_handler *sig_data;
 
@@ -57,7 +58,8 @@ int register_signal_handler(unsigned int subsys, signal_cbfn *cbfn, void *data)
 	return 0;
 }
 
-void unregister_signal_handler(unsigned int subsys, signal_cbfn *cbfn, void *data)
+void osmo_signal_unregister_handler(unsigned int subsys,
+				    osmo_signal_cbfn *cbfn, void *data)
 {
 	struct signal_handler *handler;
 
@@ -72,7 +74,8 @@ void unregister_signal_handler(unsigned int subsys, signal_cbfn *cbfn, void *dat
 }
 
 
-void dispatch_signal(unsigned int subsys, unsigned int signal, void *signal_data)
+void osmo_signal_dispatch(unsigned int subsys, unsigned int signal,
+			  void *signal_data)
 {
 	struct signal_handler *handler;
 
diff --git a/src/shared/libosmocore/src/statistics.c b/src/shared/libosmocore/src/statistics.c
index 83bb6ed3..e28541ba 100644
--- a/src/shared/libosmocore/src/statistics.c
+++ b/src/shared/libosmocore/src/statistics.c
@@ -30,9 +30,9 @@ static LLIST_HEAD(counters);
 
 void *tall_ctr_ctx;
 
-struct counter *counter_alloc(const char *name)
+struct osmo_counter *osmo_counter_alloc(const char *name)
 {
-	struct counter *ctr = talloc_zero(tall_ctr_ctx, struct counter);
+	struct osmo_counter *ctr = talloc_zero(tall_ctr_ctx, struct osmo_counter);
 
 	if (!ctr)
 		return NULL;
@@ -43,15 +43,16 @@ struct counter *counter_alloc(const char *name)
 	return ctr;
 }
 
-void counter_free(struct counter *ctr)
+void osmo_counter_free(struct osmo_counter *ctr)
 {
 	llist_del(&ctr->list);
 	talloc_free(ctr);
 }
 
-int counters_for_each(int (*handle_counter)(struct counter *, void *), void *data)
+int osmo_counters_for_each(int (*handle_counter)(struct osmo_counter *, void *),
+			   void *data)
 {
-	struct counter *ctr;
+	struct osmo_counter *ctr;
 	int rc = 0;
 
 	llist_for_each_entry(ctr, &counters, list) {
@@ -63,9 +64,9 @@ int counters_for_each(int (*handle_counter)(struct counter *, void *), void *dat
 	return rc;
 }
 
-struct counter *counter_get_by_name(const char *name)
+struct osmo_counter *osmo_counter_get_by_name(const char *name)
 {
-	struct counter *ctr;
+	struct osmo_counter *ctr;
 
 	llist_for_each_entry(ctr, &counters, list) {
 		if (!strcmp(ctr->name, name))
diff --git a/src/shared/libosmocore/src/timer.c b/src/shared/libosmocore/src/timer.c
index 9b2dd9e9..ec752123 100644
--- a/src/shared/libosmocore/src/timer.c
+++ b/src/shared/libosmocore/src/timer.c
@@ -31,9 +31,9 @@ static struct timeval s_select_time;
 #define TIME_SMALLER(left, right) \
         (left.tv_sec*MICRO_SECONDS+left.tv_usec) <= (right.tv_sec*MICRO_SECONDS+right.tv_usec)
 
-void bsc_add_timer(struct timer_list *timer)
+void osmo_timer_add(struct osmo_timer_list *timer)
 {
-	struct timer_list *list_timer;
+	struct osmo_timer_list *list_timer;
 
 	/* TODO: Optimize and remember the closest item... */
 	timer->active = 1;
@@ -47,7 +47,8 @@ void bsc_add_timer(struct timer_list *timer)
 	llist_add(&timer->entry, &timer_list);
 }
 
-void bsc_schedule_timer(struct timer_list *timer, int seconds, int microseconds)
+void
+osmo_timer_schedule(struct osmo_timer_list *timer, int seconds, int microseconds)
 {
 	struct timeval current_time;
 
@@ -56,10 +57,10 @@ void bsc_schedule_timer(struct timer_list *timer, int seconds, int microseconds)
 	currentTime += seconds * MICRO_SECONDS + microseconds;
 	timer->timeout.tv_sec = currentTime / MICRO_SECONDS;
 	timer->timeout.tv_usec = currentTime % MICRO_SECONDS;
-	bsc_add_timer(timer);
+	osmo_timer_add(timer);
 }
 
-void bsc_del_timer(struct timer_list *timer)
+void osmo_timer_del(struct osmo_timer_list *timer)
 {
 	if (timer->in_list) {
 		timer->active = 0;
@@ -68,7 +69,7 @@ void bsc_del_timer(struct timer_list *timer)
 	}
 }
 
-int bsc_timer_pending(struct timer_list *timer)
+int osmo_timer_pending(struct osmo_timer_list *timer)
 {
 	return timer->active;
 }
@@ -79,7 +80,7 @@ int bsc_timer_pending(struct timer_list *timer)
  * If the nearest timer timed out return NULL and then we will
  * dispatch everything after the select
  */
-struct timeval *bsc_nearest_timer()
+struct timeval *osmo_timers_nearest()
 {
 	struct timeval current_time;
 
@@ -106,9 +107,9 @@ struct timeval *bsc_nearest_timer()
 /*
  * Find the nearest time and update s_nearest_time
  */
-void bsc_prepare_timers()
+void osmo_timers_prepare()
 {
-	struct timer_list *timer, *nearest_timer = NULL;
+	struct osmo_timer_list *timer, *nearest_timer = NULL;
 	llist_for_each_entry(timer, &timer_list, entry) {
 		if (!nearest_timer || TIME_SMALLER(timer->timeout, nearest_timer->timeout)) {
 			nearest_timer = timer;
@@ -125,10 +126,10 @@ void bsc_prepare_timers()
 /*
  * fire all timers... and remove them
  */
-int bsc_update_timers()
+int osmo_timers_update()
 {
 	struct timeval current_time;
-	struct timer_list *timer, *tmp;
+	struct osmo_timer_list *timer, *tmp;
 	int work = 0;
 
 	gettimeofday(&current_time, NULL);
@@ -166,16 +167,16 @@ restart:
 	llist_for_each_entry_safe(timer, tmp, &timer_list, entry) {
 		timer->handled = 0;
 		if (!timer->active) {
-			bsc_del_timer(timer);
+			osmo_timer_del(timer);
 		}
 	}
 
 	return work;
 }
 
-int bsc_timer_check(void)
+int osmo_timers_check(void)
 {
-	struct timer_list *timer;
+	struct osmo_timer_list *timer;
 	int i = 0;
 
 	llist_for_each_entry(timer, &timer_list, entry) {
diff --git a/src/shared/libosmocore/src/utils.c b/src/shared/libosmocore/src/utils.c
index af1829c9..3ee14abd 100644
--- a/src/shared/libosmocore/src/utils.c
+++ b/src/shared/libosmocore/src/utils.c
@@ -35,7 +35,7 @@ int get_string_value(const struct value_string *vs, const char *str)
 	return -EINVAL;
 }
 
-char bcd2char(uint8_t bcd)
+char osmo_bcd2char(uint8_t bcd)
 {
 	if (bcd < 0xa)
 		return '0' + bcd;
@@ -44,12 +44,12 @@ char bcd2char(uint8_t bcd)
 }
 
 /* only works for numbers in ascii */
-uint8_t char2bcd(char c)
+uint8_t osmo_char2bcd(char c)
 {
 	return c - 0x30;
 }
 
-int hexparse(const char *str, uint8_t *b, int max_len)
+int osmo_hexparse(const char *str, uint8_t *b, int max_len)
 
 {
 	int i, l, v;
@@ -78,7 +78,7 @@ int hexparse(const char *str, uint8_t *b, int max_len)
 
 static char hexd_buff[4096];
 
-static char *_hexdump(const unsigned char *buf, int len, char *delim)
+static char *_osmo_hexdump(const unsigned char *buf, int len, char *delim)
 {
 	int i;
 	char *cur = hexd_buff;
@@ -95,7 +95,7 @@ static char *_hexdump(const unsigned char *buf, int len, char *delim)
 	return hexd_buff;
 }
 
-char *ubit_dump(const uint8_t *bits, unsigned int len)
+char *osmo_ubit_dump(const uint8_t *bits, unsigned int len)
 {
 	int i;
 
@@ -125,14 +125,14 @@ char *ubit_dump(const uint8_t *bits, unsigned int len)
 	return hexd_buff;
 }
 
-char *hexdump(const unsigned char *buf, int len)
+char *osmo_hexdump(const unsigned char *buf, int len)
 {
-	return _hexdump(buf, len, " ");
+	return _osmo_hexdump(buf, len, " ");
 }
 
-char *hexdump_nospc(const unsigned char *buf, int len)
+char *osmo_osmo_hexdump_nospc(const unsigned char *buf, int len)
 {
-	return _hexdump(buf, len, "");
+	return _osmo_hexdump(buf, len, "");
 }
 
 #include "../config.h"
diff --git a/src/shared/libosmocore/src/vty/Makefile.am b/src/shared/libosmocore/src/vty/Makefile.am
index 7353ab84..b7be6f84 100644
--- a/src/shared/libosmocore/src/vty/Makefile.am
+++ b/src/shared/libosmocore/src/vty/Makefile.am
@@ -10,5 +10,6 @@ lib_LTLIBRARIES = libosmovty.la
 
 libosmovty_la_SOURCES = buffer.c command.c vty.c vector.c utils.c \
 			telnet_interface.c logging_vty.c
+libosmovty_la_LDFLAGS = -version-info $(LIBVERSION)
 libosmovty_la_LIBADD = $(top_builddir)/src/libosmocore.la
 endif
diff --git a/src/shared/libosmocore/src/vty/telnet_interface.c b/src/shared/libosmocore/src/vty/telnet_interface.c
index 0d45d614..78459944 100644
--- a/src/shared/libosmocore/src/vty/telnet_interface.c
+++ b/src/shared/libosmocore/src/vty/telnet_interface.c
@@ -39,9 +39,9 @@ LLIST_HEAD(active_connections);
 static void *tall_telnet_ctx;
 
 /* per network data */
-static int telnet_new_connection(struct bsc_fd *fd, unsigned int what);
+static int telnet_new_connection(struct osmo_fd *fd, unsigned int what);
 
-static struct bsc_fd server_socket = {
+static struct osmo_fd server_socket = {
 	.when	    = BSC_FD_READ,
 	.cb	    = telnet_new_connection,
 	.priv_nr    = 0,
@@ -85,7 +85,7 @@ int telnet_init(void *tall_ctx, void *priv, int port)
 
 	server_socket.data = priv;
 	server_socket.fd = fd;
-	bsc_register_fd(&server_socket);
+	osmo_fd_register(&server_socket);
 
 	return 0;
 }
@@ -104,12 +104,12 @@ static void print_welcome(int fd)
 		ret = write(fd, host.app_info->copyright, strlen(host.app_info->copyright));
 }
 
-int telnet_close_client(struct bsc_fd *fd)
+int telnet_close_client(struct osmo_fd *fd)
 {
 	struct telnet_connection *conn = (struct telnet_connection*)fd->data;
 
 	close(fd->fd);
-	bsc_unregister_fd(fd);
+	osmo_fd_unregister(fd);
 
 	if (conn->dbg) {
 		log_del_target(conn->dbg);
@@ -121,7 +121,7 @@ int telnet_close_client(struct bsc_fd *fd)
 	return 0;
 }
 
-static int client_data(struct bsc_fd *fd, unsigned int what)
+static int client_data(struct osmo_fd *fd, unsigned int what)
 {
 	struct telnet_connection *conn = fd->data;
 	int rc = 0;
@@ -144,7 +144,7 @@ static int client_data(struct bsc_fd *fd, unsigned int what)
 	return rc;
 }
 
-static int telnet_new_connection(struct bsc_fd *fd, unsigned int what)
+static int telnet_new_connection(struct osmo_fd *fd, unsigned int what)
 {
 	struct telnet_connection *connection;
 	struct sockaddr_in sockaddr;
@@ -162,7 +162,7 @@ static int telnet_new_connection(struct bsc_fd *fd, unsigned int what)
 	connection->fd.fd = new_connection;
 	connection->fd.when = BSC_FD_READ;
 	connection->fd.cb = client_data;
-	bsc_register_fd(&connection->fd);
+	osmo_fd_register(&connection->fd);
 	llist_add_tail(&connection->entry, &active_connections);
 
 	print_welcome(new_connection);
@@ -182,7 +182,7 @@ static int telnet_new_connection(struct bsc_fd *fd, unsigned int what)
 void vty_event(enum event event, int sock, struct vty *vty)
 {
 	struct telnet_connection *connection = vty->priv;
-	struct bsc_fd *bfd = &connection->fd;
+	struct osmo_fd *bfd = &connection->fd;
 
 	if (vty->type != VTY_TERM)
 		return;
diff --git a/src/shared/libosmocore/src/write_queue.c b/src/shared/libosmocore/src/write_queue.c
index 0642aad6..a5921042 100644
--- a/src/shared/libosmocore/src/write_queue.c
+++ b/src/shared/libosmocore/src/write_queue.c
@@ -23,11 +23,11 @@
 
 #include <osmocom/core/write_queue.h>
 
-int write_queue_bfd_cb(struct bsc_fd *fd, unsigned int what)
+int osmo_wqueue_bfd_cb(struct osmo_fd *fd, unsigned int what)
 {
-	struct write_queue *queue;
+	struct osmo_wqueue *queue;
 
-	queue = container_of(fd, struct write_queue, bfd);
+	queue = container_of(fd, struct osmo_wqueue, bfd);
 
 	if (what & BSC_FD_READ)
 		queue->read_cb(fd);
@@ -56,17 +56,17 @@ int write_queue_bfd_cb(struct bsc_fd *fd, unsigned int what)
 	return 0;
 }
 
-void write_queue_init(struct write_queue *queue, int max_length)
+void osmo_wqueue_init(struct osmo_wqueue *queue, int max_length)
 {
 	queue->max_length = max_length;
 	queue->current_length = 0;
 	queue->read_cb = NULL;
 	queue->write_cb = NULL;
-	queue->bfd.cb = write_queue_bfd_cb;
+	queue->bfd.cb = osmo_wqueue_bfd_cb;
 	INIT_LLIST_HEAD(&queue->msg_queue);
 }
 
-int write_queue_enqueue(struct write_queue *queue, struct msgb *data)
+int osmo_wqueue_enqueue(struct osmo_wqueue *queue, struct msgb *data)
 {
 //	if (queue->current_length + 1 >= queue->max_length)
 //		LOGP(DMSC, LOGL_ERROR, "The queue is full. Dropping not yet implemented.\n");
@@ -78,7 +78,7 @@ int write_queue_enqueue(struct write_queue *queue, struct msgb *data)
 	return 0;
 }
 
-void write_queue_clear(struct write_queue *queue)
+void osmo_wqueue_clear(struct osmo_wqueue *queue)
 {
 	while (!llist_empty(&queue->msg_queue)) {
 		struct msgb *msg = msgb_dequeue(&queue->msg_queue);
diff --git a/src/shared/libosmocore/tests/msgfile/msgfile_test.c b/src/shared/libosmocore/tests/msgfile/msgfile_test.c
index 4637ceab..ed7aa978 100644
--- a/src/shared/libosmocore/tests/msgfile/msgfile_test.c
+++ b/src/shared/libosmocore/tests/msgfile/msgfile_test.c
@@ -23,9 +23,9 @@
 
 #include <stdio.h>
 
-static void dump_entries(struct msg_entries *entries)
+static void dump_entries(struct osmo_config_list *entries)
 {
-	struct msg_entry *entry;
+	struct osmo_config_entry *entry;
 
 	if (!entries) {
 		fprintf(stderr, "Failed to parse the file\n");
@@ -40,10 +40,10 @@ static void dump_entries(struct msg_entries *entries)
 
 int main(int argc, char **argv)
 {
-	struct msg_entries *entries;
+	struct osmo_config_list *entries;
 
 	/* todo use msgfile_test.c.in and replace the path */
-	entries = msg_entry_parse(NULL, "msgconfig.cfg");
+	entries = osmo_config_list_parse(NULL, "msgconfig.cfg");
 	dump_entries(entries);
 
 	return 0;
diff --git a/src/shared/libosmocore/tests/timer/timer_test.c b/src/shared/libosmocore/tests/timer/timer_test.c
index 30b08ad0..240bc480 100644
--- a/src/shared/libosmocore/tests/timer/timer_test.c
+++ b/src/shared/libosmocore/tests/timer/timer_test.c
@@ -27,17 +27,17 @@
 
 static void timer_fired(void *data);
 
-static struct timer_list timer_one = {
+static struct osmo_timer_list timer_one = {
     .cb = timer_fired,
     .data = (void*)1,
 };
 
-static struct timer_list timer_two = {
+static struct osmo_timer_list timer_two = {
     .cb = timer_fired,
     .data = (void*)2,
 };
 
-static struct timer_list timer_three = {
+static struct osmo_timer_list timer_three = {
     .cb = timer_fired,
     .data = (void*)3,
 };
@@ -48,8 +48,8 @@ static void timer_fired(void *_data)
     printf("Fired timer: %lu\n", data);
 
     if (data == 1) {
-        bsc_schedule_timer(&timer_one, 3, 0);
-        bsc_del_timer(&timer_two);
+        osmo_timer_schedule(&timer_one, 3, 0);
+        osmo_timer_del(&timer_two);
     } else if (data == 2) {
         printf("Should not be fired... bug in del_timer\n");
     } else if (data == 3) {
@@ -63,13 +63,13 @@ int main(int argc, char** argv)
 {
     printf("Starting... timer\n");
 
-    bsc_schedule_timer(&timer_one, 3, 0);
-    bsc_schedule_timer(&timer_two, 5, 0);
-    bsc_schedule_timer(&timer_three, 4, 0);
+    osmo_timer_schedule(&timer_one, 3, 0);
+    osmo_timer_schedule(&timer_two, 5, 0);
+    osmo_timer_schedule(&timer_three, 4, 0);
 
 #ifdef HAVE_SYS_SELECT_H
     while (1) {
-        bsc_select_main(0);
+        osmo_select_main(0);
     }
 #else
     printf("Select not supported on this platform!\n");