diff --git a/openbsc/include/openbsc/mgcp_internal.h b/openbsc/include/openbsc/mgcp_internal.h
index d59c5d7..20c433a 100644
--- a/openbsc/include/openbsc/mgcp_internal.h
+++ b/openbsc/include/openbsc/mgcp_internal.h
@@ -114,6 +114,12 @@
 	struct sockaddr_in forward;
 };
 
+struct mgcp_lco {
+	char *string;
+	int pkt_period_min; /* time in ms */
+	int pkt_period_max; /* time in ms */
+};
+
 enum mgcp_type {
 	MGCP_RTP_DEFAULT	= 0,
 	MGCP_RTP_TRANSCODED,
@@ -123,7 +129,7 @@
 	int allocated;
 	uint32_t ci;
 	char *callid;
-	char *local_options;
+	struct mgcp_lco local_options;
 	int conn_mode;
 	int orig_mode;
 
diff --git a/openbsc/src/libmgcp/mgcp_protocol.c b/openbsc/src/libmgcp/mgcp_protocol.c
index ab94164..c4ff757 100644
--- a/openbsc/src/libmgcp/mgcp_protocol.c
+++ b/openbsc/src/libmgcp/mgcp_protocol.c
@@ -614,6 +614,25 @@
 	return found_media;
 }
 
+/* Set the LCO from a string (see RFC 3435).
+ * The string is stored in the 'string' field. A NULL string is handled excatly
+ * like an empty string, the 'string' field is never NULL after this function
+ * has been called. */
+static void set_local_cx_options(void *ctx, struct mgcp_lco *lco,
+				 const char *options)
+{
+	char *p_opt;
+
+	talloc_free(lco->string);
+	lco->pkt_period_min = lco->pkt_period_max = 0;
+	lco->string = talloc_strdup(ctx, options ? options : "");
+
+	p_opt = strstr(lco->string, "p:");
+	if (p_opt && sscanf(p_opt, "p:%d-%d",
+			    &lco->pkt_period_min, &lco->pkt_period_max) == 1)
+		lco->pkt_period_max = lco->pkt_period_min;
+}
+
 void mgcp_rtp_end_config(struct mgcp_endpoint *endp, int expect_ssrc_change,
 			 struct mgcp_rtp_end *rtp)
 {
@@ -712,8 +731,8 @@
 	/* copy some parameters */
 	endp->callid = talloc_strdup(tcfg->endpoints, callid);
 
-	if (local_options)
-		endp->local_options = talloc_strdup(tcfg->endpoints, local_options);
+	set_local_cx_options(endp->tcfg->endpoints, &endp->local_options,
+			     local_options);
 
 	if (parse_conn_mode(mode, &endp->conn_mode) != 0) {
 		    error_code = 517;
@@ -789,6 +808,7 @@
 	int error_code = 500;
 	int silent = 0;
 	char *line;
+	const char *local_options = NULL;
 
 	if (p->found != 0)
 		return create_err_response(NULL, 510, "MDCX", p->trans);
@@ -812,7 +832,7 @@
 			break;
 		}
 		case 'L':
-			/* skip */
+			local_options = (const char *) line + 3;
 			break;
 		case 'M':
 			if (parse_conn_mode(line + 3, &endp->conn_mode) != 0) {
@@ -838,6 +858,9 @@
 		}
 	}
 
+	set_local_cx_options(endp->tcfg->endpoints, &endp->local_options,
+			     local_options);
+
 	/* policy CB */
 	if (p->cfg->policy_cb) {
 		int rc;
@@ -1148,8 +1171,8 @@
 	talloc_free(endp->callid);
 	endp->callid = NULL;
 
-	talloc_free(endp->local_options);
-	endp->local_options = NULL;
+	talloc_free(endp->local_options.string);
+	endp->local_options.string = NULL;
 
 	mgcp_rtp_end_reset(&endp->bts_end);
 	mgcp_rtp_end_reset(&endp->net_end);
diff --git a/openbsc/tests/mgcp/mgcp_test.c b/openbsc/tests/mgcp/mgcp_test.c
index bea9771..8b5e17d 100644
--- a/openbsc/tests/mgcp/mgcp_test.c
+++ b/openbsc/tests/mgcp/mgcp_test.c
@@ -319,7 +319,14 @@
 				       endp->net_end.packet_duration_ms);
 			else
 				printf("Packet duration not set\n");
-			printf("Requested packetization period not set\n");
+			if (endp->local_options.pkt_period_min ||
+			    endp->local_options.pkt_period_max)
+				printf("Requested packetetization period: "
+				       "%d-%d\n",
+				       endp->local_options.pkt_period_min,
+				       endp->local_options.pkt_period_max);
+			else
+				printf("Requested packetization period not set\n");
 
 			endp->net_end.packet_duration_ms = -1;
 		}
diff --git a/openbsc/tests/mgcp/mgcp_test.ok b/openbsc/tests/mgcp/mgcp_test.ok
index 509958a..24f9b33 100644
--- a/openbsc/tests/mgcp/mgcp_test.ok
+++ b/openbsc/tests/mgcp/mgcp_test.ok
@@ -17,19 +17,19 @@
 Testing MDCX2
 Testing CRCX
 Packet duration not set
-Requested packetization period not set
+Requested packetetization period: 20-20
 Testing MDCX3
 Packet duration not set
 Requested packetization period not set
 Testing MDCX4
 Packet duration not set
-Requested packetization period not set
+Requested packetetization period: 20-20
 Testing MDCX4_PT1
 Packet duration not set
-Requested packetization period not set
+Requested packetetization period: 20-40
 Testing MDCX4_PT2
 Packet duration not set
-Requested packetization period not set
+Requested packetetization period: 20-20
 Testing MDCX4_PT3
 Packet duration not set
 Requested packetization period not set
