session client UPDATE enable raw message handling

Author: michalvasko

src/io.c

@@ -831,7 +831,7 @@ nc_write_msg_io(struct nc_session *session, int io_timeout, int type, ...)
     char *buf;
     struct nc_wclb_arg arg;
     const char **capabilities;
-    uint32_t *sid = NULL, i, wd = 0;
+    uint32_t *sid = NULL, i, wd = 0, str_len;
     LY_ERR lyrc;
 
     assert(session);
@@ -1042,6 +1042,16 @@ nc_write_msg_io(struct nc_session *session, int io_timeout, int type, ...)
         }
         break;
 
+    case NC_MSG_RAW:
+        str = va_arg(ap, const char *);
+        str_len = va_arg(ap, uint32_t);
+
+        /* write the message */
+        nc_write_clb((void *)&arg, str, str_len, 0);
+
+        session->opts.client.msgid++;
+        break;
+
     default:
         ret = NC_MSG_ERROR;
         goto cleanup;

src/netconf.h

@@ -75,7 +75,8 @@ typedef enum {
     NC_MSG_RPC,             /**< \<rpc\> message */
     NC_MSG_REPLY,           /**< \<rpc-reply\> message */
     NC_MSG_REPLY_ERR_MSGID, /**< \<rpc-reply\> message with missing or wrong message-id attribute value */
-    NC_MSG_NOTIF            /**< \<notification\> message */
+    NC_MSG_NOTIF,           /**< \<notification\> message */
+    NC_MSG_RAW              /**< raw string message */
 } NC_MSG_TYPE;
 
 /**

src/session_client.c

@@ -2588,6 +2588,35 @@ nc_recv_notif_dispatch_data(struct nc_session *session, nc_notif_dispatch_clb no
     return 0;
 }
 
+API int
+nc_recv_msg(struct nc_session *session, int timeout, char **msg)
+{
+    struct ly_in *msg_in = NULL;
+    NC_MSG_TYPE ret;
+    ly_bool msg_destroy = 1;
+
+    NC_CHECK_ARG_RET(session, session, msg, NC_MSG_ERROR);
+
+    if ((session->status != NC_STATUS_RUNNING) || (session->side != NC_CLIENT)) {
+        ERR(session, "Invalid session to receive RPC replies.");
+        return NC_MSG_ERROR;
+    }
+
+    /* receive a message */
+    ret = recv_msg(session, timeout, NC_MSG_REPLY, &msg_in);
+    if (ret != NC_MSG_REPLY) {
+        goto cleanup;
+    }
+
+    /* get the message string */
+    *msg = (char *)ly_in_memory(msg_in, NULL);
+    msg_destroy = 0;
+
+cleanup:
+    ly_in_free(msg_in, msg_destroy);
+    return ret;
+}
+
 void
 nc_client_notification_threads_stop(struct nc_session *session)
 {
@@ -3242,6 +3271,33 @@ nc_send_rpc(struct nc_session *session, struct nc_rpc *rpc, int timeout, uint64_
     return r;
 }
 
+API NC_MSG_TYPE
+nc_send_msg(struct nc_session *session, const char *msg, uint32_t msg_len, int timeout, uint64_t *msgid)
+{
+    NC_MSG_TYPE r;
+    uint64_t cur_msgid;
+
+    NC_CHECK_ARG_RET(session, session, msg, NC_MSG_ERROR);
+
+    if ((session->status != NC_STATUS_RUNNING) || (session->side != NC_CLIENT)) {
+        ERR(session, "Invalid session to send RPCs.");
+        return NC_MSG_ERROR;
+    }
+
+    if (!msg_len) {
+        msg_len = strlen(msg);
+    }
+
+    /* send RPC, store its message ID */
+    r = nc_write_msg_io(session, timeout, NC_MSG_RAW, msg, msg_len);
+    cur_msgid = session->opts.client.msgid;
+
+    if (msgid && (r == NC_MSG_RPC)) {
+        *msgid = cur_msgid;
+    }
+    return r;
+}
+
 API void
 nc_client_session_set_not_strict(struct nc_session *session)
 {

src/session_client.h

@@ -500,8 +500,6 @@ int nc_session_ntf_thread_running(const struct nc_session *session);
 /**
  * @brief Receive NETCONF RPC reply.
  *
- * @note This function can be called in a single thread only.
- *
  * @param[in] session NETCONF session from which the function gets data. It must be the
  * client side session object.
  * @param[in] rpc Original RPC this should be the reply to.
@@ -575,6 +573,24 @@ int nc_recv_notif_dispatch(struct nc_session *session, nc_notif_dispatch_clb not
 int nc_recv_notif_dispatch_data(struct nc_session *session, nc_notif_dispatch_clb notif_clb, void *user_data,
         void (*free_data)(void *));
 
+/**
+ * @brief Receive a reply message.
+ *
+ * Allows receiving raw NETCONF messages and does not perform any checks including message-id matching.
+ * For all valid messages, ::nc_recv_reply() should be used instead.
+ *
+ * @param[in] session NETCONF session from which the function gets data. It must be the
+ * client side session object.
+ * @param[in] timeout Timeout for reading in milliseconds. Use negative value for infinite
+ * waiting and 0 for immediate return if data are not available on the wire.
+ * @param[out] msg Received message as a string.
+ * @return #NC_MSG_REPLY for success,
+ *         #NC_MSG_WOULDBLOCK if @p timeout has elapsed,
+ *         #NC_MSG_ERROR if reading has failed,
+ *         #NC_MSG_NOTIF if a notification was read instead (call this function again to get the reply).
+ */
+int nc_recv_msg(struct nc_session *session, int timeout, char **msg);
+
 /**
  * @brief Send NETCONF RPC message via the session.
  *
@@ -589,6 +605,24 @@ int nc_recv_notif_dispatch_data(struct nc_session *session, nc_notif_dispatch_cl
  */
 NC_MSG_TYPE nc_send_rpc(struct nc_session *session, struct nc_rpc *rpc, int timeout, uint64_t *msgid);
 
+/**
+ * @brief Send a message via the session.
+ *
+ * Allows for sending arbitrary NETCONF-encoded messages. For all valid messages, ::nc_send_rpc() should be used
+ * instead.
+ *
+ * @param[in] session NETCONF session where the RPC will be written.
+ * @param[in] msg Message (XML-encoded) to send.
+ * @param[in] msg_len Length of @p msg. May be 0 if it is 0-terminated.
+ * @param[in] timeout Timeout for writing in milliseconds. Use negative value for infinite
+ * waiting and 0 for return if data cannot be sent immediately.
+ * @param[out] msgid Optional, if RPC was successfully sent, this is it's message ID.
+ * @return #NC_MSG_RPC on success,
+ *         #NC_MSG_WOULDBLOCK in case of a busy session, and
+ *         #NC_MSG_ERROR on error.
+ */
+NC_MSG_TYPE nc_send_msg(struct nc_session *session, const char *msg, uint32_t msg_len, int timeout, uint64_t *msgid);
+
 /**
  * @brief Make a session not strict when sending RPCs and receiving RPC replies. In other words,
  * it will silently skip unknown nodes without an error.

src/session_p.h

@@ -1562,6 +1562,9 @@ int nc_write_clb(struct nc_wclb_arg *arg, const void *buf, uint32_t count, int x
  * - #NC_MSG_HELLO
  *   - `const char **capabs;` - capabilities array ended with NULL. Required parameter.
  *   - `uint32_t *sid;` - session ID to be included in the hello message. Optional parameter.
+ * - #NC_MSG_RAW
+ *   - `const char *msg;` - string message to print. Required parameter.
+ *   - `uint32_t msg_len;` - message length. Required parameter.
  *
  * @return Type of the written message. #NC_MSG_WOULDBLOCK is returned if timeout is positive
  * (or zero) value and IO lock could not be acquired in that time. #NC_MSG_ERROR is