diff --git a/src/osmo_server_network.c b/src/osmo_server_network.c
index be61d03..513ca1f 100644
--- a/src/osmo_server_network.c
+++ b/src/osmo_server_network.c
@@ -253,6 +253,11 @@
 	conn = fd->data;
 
 	if (conn->state == STATE_INITIAL) {
+		if (conn->reopen) {
+			LOGP(DSERVER, LOGL_INFO, "Reopening log for %s now.\n", conn->name);
+			restart_pcap(conn);
+			conn->reopen = 0;
+		}
 		return read_cb_initial(fd, conn);
 	} else if (conn->state == STATE_DATA) {
 		return read_cb_data(fd, conn);
@@ -336,3 +341,18 @@
 
 	return 0;
 }
+
+void osmo_pcap_server_reopen(struct osmo_pcap_server *server)
+{
+	struct osmo_pcap_conn *conn;
+	LOGP(DSERVER, LOGL_INFO, "Reopening all logfiles.\n");
+	llist_for_each_entry(conn, &server->conn, entry) {
+		/* Write the complete packet out first */
+		if (conn->state == STATE_INITIAL) {
+			restart_pcap(conn);
+		} else {
+			LOGP(DSERVER, LOGL_INFO, "Delaying %s until current packet is complete.\n", conn->name);
+			conn->reopen = 1;
+		}
+	}
+}
