2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
3 * Copyright (C) 2011-2013 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; only
8 * version 2.1 of the License.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 #include <sys/socket.h>
27 #include <sys/types.h>
34 #include <lttng/ust-ctl.h>
37 #include <lttng/ust-error.h>
38 #include <lttng/ust-events.h>
39 #include <usterr-signal-safe.h>
41 #include "../liblttng-ust/compat.h"
43 #define USTCOMM_CODE_OFFSET(code) \
44 (code == LTTNG_UST_OK ? 0 : (code - LTTNG_UST_ERR + 1))
46 #define USTCOMM_MAX_SEND_FDS 4
49 * Human readable error message.
51 static const char *ustcomm_readable_code
[] = {
52 [ USTCOMM_CODE_OFFSET(LTTNG_UST_OK
) ] = "Success",
53 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR
) ] = "Unknown error",
54 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_NOENT
) ] = "No entry",
55 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_EXIST
) ] = "Object already exists",
56 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_INVAL
) ] = "Invalid argument",
57 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_PERM
) ] = "Permission denied",
58 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_NOSYS
) ] = "Not implemented",
59 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_EXITING
) ] = "Process is exiting",
61 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_INVAL_MAGIC
) ] = "Invalid magic number",
62 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_INVAL_SOCKET_TYPE
) ] = "Invalid socket type",
63 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_UNSUP_MAJOR
) ] = "Unsupported major version",
69 * Receives positive error value.
70 * Return ptr to string representing a human readable
71 * error code from the ustcomm_return_code enum.
73 const char *lttng_ust_strerror(int code
)
75 if (code
== LTTNG_UST_OK
)
76 return ustcomm_readable_code
[USTCOMM_CODE_OFFSET(code
)];
77 if (code
< LTTNG_UST_ERR
)
78 return strerror(code
);
79 if (code
>= LTTNG_UST_ERR_NR
)
81 return ustcomm_readable_code
[USTCOMM_CODE_OFFSET(code
)];
86 * ustcomm_connect_unix_sock
88 * Connect to unix socket using the path name.
90 int ustcomm_connect_unix_sock(const char *pathname
)
92 struct sockaddr_un sun
;
96 * libust threads require the close-on-exec flag for all
97 * resources so it does not leak file descriptors upon exec.
99 fd
= socket(PF_UNIX
, SOCK_STREAM
, 0);
105 ret
= fcntl(fd
, F_SETFD
, FD_CLOEXEC
);
112 memset(&sun
, 0, sizeof(sun
));
113 sun
.sun_family
= AF_UNIX
;
114 strncpy(sun
.sun_path
, pathname
, sizeof(sun
.sun_path
));
115 sun
.sun_path
[sizeof(sun
.sun_path
) - 1] = '\0';
117 ret
= connect(fd
, (struct sockaddr
*) &sun
, sizeof(sun
));
120 * Don't print message on connect error, because connect
121 * is used in normal execution to detect if sessiond is
135 closeret
= close(fd
);
144 * ustcomm_accept_unix_sock
146 * Do an accept(2) on the sock and return the
147 * new file descriptor. The socket MUST be bind(2) before.
149 int ustcomm_accept_unix_sock(int sock
)
152 struct sockaddr_un sun
;
156 new_fd
= accept(sock
, (struct sockaddr
*) &sun
, &len
);
158 if (errno
!= ECONNABORTED
)
161 if (new_fd
== -ECONNABORTED
)
168 * ustcomm_create_unix_sock
170 * Creates a AF_UNIX local socket using pathname
171 * bind the socket upon creation and return the fd.
173 int ustcomm_create_unix_sock(const char *pathname
)
175 struct sockaddr_un sun
;
178 /* Create server socket */
179 if ((fd
= socket(PF_UNIX
, SOCK_STREAM
, 0)) < 0) {
185 memset(&sun
, 0, sizeof(sun
));
186 sun
.sun_family
= AF_UNIX
;
187 strncpy(sun
.sun_path
, pathname
, sizeof(sun
.sun_path
));
188 sun
.sun_path
[sizeof(sun
.sun_path
) - 1] = '\0';
190 /* Unlink the old file if present */
191 (void) unlink(pathname
);
192 ret
= bind(fd
, (struct sockaddr
*) &sun
, sizeof(sun
));
205 closeret
= close(fd
);
215 * ustcomm_listen_unix_sock
217 * Make the socket listen using LTTNG_UST_COMM_MAX_LISTEN.
219 int ustcomm_listen_unix_sock(int sock
)
223 ret
= listen(sock
, LTTNG_UST_COMM_MAX_LISTEN
);
233 * ustcomm_close_unix_sock
235 * Shutdown cleanly a unix socket.
237 int ustcomm_close_unix_sock(int sock
)
251 * ustcomm_recv_unix_sock
253 * Receive data of size len in put that data into
254 * the buf param. Using recvmsg API.
255 * Return the size of received data.
256 * Return 0 on orderly shutdown.
258 ssize_t
ustcomm_recv_unix_sock(int sock
, void *buf
, size_t len
)
264 memset(&msg
, 0, sizeof(msg
));
266 iov
[0].iov_base
= buf
;
267 iov
[0].iov_len
= len
;
272 ret
= recvmsg(sock
, &msg
, 0);
273 } while (ret
< 0 && errno
== EINTR
);
278 if (errno
!= EPIPE
&& errno
!= ECONNRESET
)
281 if (ret
== -ECONNRESET
)
284 shutret
= shutdown(sock
, SHUT_RDWR
);
286 ERR("Socket shutdown error");
293 * ustcomm_send_unix_sock
295 * Send buf data of size len. Using sendmsg API.
296 * Return the size of sent data.
298 ssize_t
ustcomm_send_unix_sock(int sock
, const void *buf
, size_t len
)
304 memset(&msg
, 0, sizeof(msg
));
306 iov
[0].iov_base
= (void *) buf
;
307 iov
[0].iov_len
= len
;
312 * Using the MSG_NOSIGNAL when sending data from sessiond to
313 * libust, so libust does not receive an unhandled SIGPIPE or
314 * SIGURG. The sessiond receiver side can be made more resilient
315 * by ignoring SIGPIPE, but we don't have this luxury on the
319 ret
= sendmsg(sock
, &msg
, MSG_NOSIGNAL
);
320 } while (ret
< 0 && errno
== EINTR
);
325 if (errno
!= EPIPE
&& errno
!= ECONNRESET
)
328 if (ret
== -ECONNRESET
)
331 shutret
= shutdown(sock
, SHUT_RDWR
);
333 ERR("Socket shutdown error");
340 * Send a message accompanied by fd(s) over a unix socket.
342 * Returns the size of data sent, or negative error value.
344 ssize_t
ustcomm_send_fds_unix_sock(int sock
, int *fds
, size_t nb_fd
)
347 struct cmsghdr
*cmptr
;
350 unsigned int sizeof_fds
= nb_fd
* sizeof(int);
351 char tmp
[CMSG_SPACE(sizeof_fds
)];
354 memset(&msg
, 0, sizeof(msg
));
355 memset(tmp
, 0, CMSG_SPACE(sizeof_fds
) * sizeof(char));
357 if (nb_fd
> USTCOMM_MAX_SEND_FDS
)
360 msg
.msg_control
= (caddr_t
)tmp
;
361 msg
.msg_controllen
= CMSG_LEN(sizeof_fds
);
363 cmptr
= CMSG_FIRSTHDR(&msg
);
364 cmptr
->cmsg_level
= SOL_SOCKET
;
365 cmptr
->cmsg_type
= SCM_RIGHTS
;
366 cmptr
->cmsg_len
= CMSG_LEN(sizeof_fds
);
367 memcpy(CMSG_DATA(cmptr
), fds
, sizeof_fds
);
368 /* Sum of the length of all control messages in the buffer: */
369 msg
.msg_controllen
= cmptr
->cmsg_len
;
371 iov
[0].iov_base
= &dummy
;
377 ret
= sendmsg(sock
, &msg
, 0);
378 } while (ret
< 0 && errno
== EINTR
);
381 * We consider EPIPE and ECONNRESET as expected.
383 if (errno
!= EPIPE
&& errno
!= ECONNRESET
) {
387 if (ret
== -ECONNRESET
)
394 * Recv a message accompanied by fd(s) from a unix socket.
396 * Returns the size of received data, or negative error value.
398 * Expect at most "nb_fd" file descriptors. Returns the number of fd
399 * actually received in nb_fd.
400 * Returns -EPIPE on orderly shutdown.
402 ssize_t
ustcomm_recv_fds_unix_sock(int sock
, int *fds
, size_t nb_fd
)
406 struct cmsghdr
*cmsg
;
407 size_t sizeof_fds
= nb_fd
* sizeof(int);
408 char recv_fd
[CMSG_SPACE(sizeof_fds
)];
412 memset(&msg
, 0, sizeof(msg
));
414 /* Prepare to receive the structures */
415 iov
[0].iov_base
= &dummy
;
419 msg
.msg_control
= recv_fd
;
420 msg
.msg_controllen
= sizeof(recv_fd
);
423 ret
= recvmsg(sock
, &msg
, 0);
424 } while (ret
< 0 && errno
== EINTR
);
426 if (errno
!= EPIPE
&& errno
!= ECONNRESET
) {
427 PERROR("recvmsg fds");
429 if (errno
== EPIPE
|| errno
== ECONNRESET
)
431 if (ret
== -ECONNRESET
)
436 /* orderly shutdown */
441 ERR("Error: Received %zd bytes, expected %d\n",
445 if (msg
.msg_flags
& MSG_CTRUNC
) {
446 ERR("Error: Control message truncated.\n");
450 cmsg
= CMSG_FIRSTHDR(&msg
);
452 ERR("Error: Invalid control message header\n");
456 if (cmsg
->cmsg_level
!= SOL_SOCKET
|| cmsg
->cmsg_type
!= SCM_RIGHTS
) {
457 ERR("Didn't received any fd\n");
461 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof_fds
)) {
462 ERR("Error: Received %zu bytes of ancillary data, expected %zu\n",
463 (size_t) cmsg
->cmsg_len
, (size_t) CMSG_LEN(sizeof_fds
));
467 memcpy(fds
, CMSG_DATA(cmsg
), sizeof_fds
);
473 int ustcomm_send_app_msg(int sock
, struct ustcomm_ust_msg
*lum
)
477 len
= ustcomm_send_unix_sock(sock
, lum
, sizeof(*lum
));
485 ERR("incorrect message size: %zd\n", len
);
492 int ustcomm_recv_app_reply(int sock
, struct ustcomm_ust_reply
*lur
,
493 uint32_t expected_handle
, uint32_t expected_cmd
)
497 memset(lur
, 0, sizeof(*lur
));
498 len
= ustcomm_recv_unix_sock(sock
, lur
, sizeof(*lur
));
500 case 0: /* orderly shutdown */
503 if (lur
->handle
!= expected_handle
) {
504 ERR("Unexpected result message handle: "
505 "expected: %u vs received: %u\n",
506 expected_handle
, lur
->handle
);
509 if (lur
->cmd
!= expected_cmd
) {
510 ERR("Unexpected result message command "
511 "expected: %u vs received: %u\n",
512 expected_cmd
, lur
->cmd
);
515 return lur
->ret_code
;
518 /* Transport level error */
519 if (errno
== EPIPE
|| errno
== ECONNRESET
)
523 ERR("incorrect message size: %zd\n", len
);
529 int ustcomm_send_app_cmd(int sock
,
530 struct ustcomm_ust_msg
*lum
,
531 struct ustcomm_ust_reply
*lur
)
535 ret
= ustcomm_send_app_msg(sock
, lum
);
538 ret
= ustcomm_recv_app_reply(sock
, lur
, lum
->handle
, lum
->cmd
);
545 * chan_data is allocated internally if this function returns the
548 ssize_t
ustcomm_recv_channel_from_sessiond(int sock
,
549 void **_chan_data
, uint64_t var_len
)
554 if (var_len
> LTTNG_UST_CHANNEL_DATA_MAX_LEN
) {
558 /* Receive variable length data */
559 chan_data
= zmalloc(var_len
);
564 len
= ustcomm_recv_unix_sock(sock
, chan_data
, var_len
);
565 if (len
!= var_len
) {
568 *_chan_data
= chan_data
;
578 int ustcomm_recv_stream_from_sessiond(int sock
,
579 uint64_t *memory_map_size
,
580 int *shm_fd
, int *wakeup_fd
)
586 /* recv shm fd and wakeup fd */
587 len
= ustcomm_recv_fds_unix_sock(sock
, fds
, 2);
606 * Returns 0 on success, negative error value on error.
608 int ustcomm_send_reg_msg(int sock
,
609 enum ustctl_socket_type type
,
610 uint32_t bits_per_long
,
611 uint32_t uint8_t_alignment
,
612 uint32_t uint16_t_alignment
,
613 uint32_t uint32_t_alignment
,
614 uint32_t uint64_t_alignment
,
615 uint32_t long_alignment
)
618 struct ustctl_reg_msg reg_msg
;
620 reg_msg
.magic
= LTTNG_UST_COMM_MAGIC
;
621 reg_msg
.major
= LTTNG_UST_ABI_MAJOR_VERSION
;
622 reg_msg
.minor
= LTTNG_UST_ABI_MINOR_VERSION
;
623 reg_msg
.pid
= getpid();
624 reg_msg
.ppid
= getppid();
625 reg_msg
.uid
= getuid();
626 reg_msg
.gid
= getgid();
627 reg_msg
.bits_per_long
= bits_per_long
;
628 reg_msg
.uint8_t_alignment
= uint8_t_alignment
;
629 reg_msg
.uint16_t_alignment
= uint16_t_alignment
;
630 reg_msg
.uint32_t_alignment
= uint32_t_alignment
;
631 reg_msg
.uint64_t_alignment
= uint64_t_alignment
;
632 reg_msg
.long_alignment
= long_alignment
;
633 reg_msg
.socket_type
= type
;
634 lttng_ust_getprocname(reg_msg
.name
);
635 memset(reg_msg
.padding
, 0, sizeof(reg_msg
.padding
));
637 len
= ustcomm_send_unix_sock(sock
, ®_msg
, sizeof(reg_msg
));
638 if (len
> 0 && len
!= sizeof(reg_msg
))
646 int serialize_basic_type(enum ustctl_abstract_types
*uatype
,
647 enum lttng_abstract_types atype
,
648 union _ustctl_basic_type
*ubt
,
649 const union _lttng_basic_type
*lbt
)
654 struct ustctl_integer_type
*uit
;
655 const struct lttng_integer_type
*lit
;
659 uit
->size
= lit
->size
;
660 uit
->signedness
= lit
->signedness
;
661 uit
->reverse_byte_order
= lit
->reverse_byte_order
;
662 uit
->base
= lit
->base
;
663 uit
->encoding
= lit
->encoding
;
664 uit
->alignment
= lit
->alignment
;
665 *uatype
= ustctl_atype_integer
;
670 ubt
->string
.encoding
= lbt
->string
.encoding
;
671 *uatype
= ustctl_atype_string
;
676 struct ustctl_float_type
*uft
;
677 const struct lttng_float_type
*lft
;
681 uft
->exp_dig
= lft
->exp_dig
;
682 uft
->mant_dig
= lft
->mant_dig
;
683 uft
->alignment
= lft
->alignment
;
684 uft
->reverse_byte_order
= lft
->reverse_byte_order
;
685 *uatype
= ustctl_atype_float
;
698 int serialize_one_type(struct ustctl_type
*ut
, const struct lttng_type
*lt
)
706 ret
= serialize_basic_type(&ut
->atype
, lt
->atype
,
707 &ut
->u
.basic
, <
->u
.basic
);
713 struct ustctl_basic_type
*ubt
;
714 const struct lttng_basic_type
*lbt
;
717 ubt
= &ut
->u
.array
.elem_type
;
718 lbt
= <
->u
.array
.elem_type
;
719 ut
->u
.array
.length
= lt
->u
.array
.length
;
720 ret
= serialize_basic_type(&ubt
->atype
, lbt
->atype
,
721 &ubt
->u
.basic
, &lbt
->u
.basic
);
724 ut
->atype
= ustctl_atype_array
;
729 struct ustctl_basic_type
*ubt
;
730 const struct lttng_basic_type
*lbt
;
733 ubt
= &ut
->u
.sequence
.length_type
;
734 lbt
= <
->u
.sequence
.length_type
;
735 ret
= serialize_basic_type(&ubt
->atype
, lbt
->atype
,
736 &ubt
->u
.basic
, &lbt
->u
.basic
);
739 ubt
= &ut
->u
.sequence
.elem_type
;
740 lbt
= <
->u
.sequence
.elem_type
;
741 ret
= serialize_basic_type(&ubt
->atype
, lbt
->atype
,
742 &ubt
->u
.basic
, &lbt
->u
.basic
);
745 ut
->atype
= ustctl_atype_sequence
;
756 int serialize_fields(size_t *_nr_write_fields
,
757 struct ustctl_field
**ustctl_fields
,
759 const struct lttng_event_field
*lttng_fields
)
761 struct ustctl_field
*fields
;
763 size_t nr_write_fields
= 0;
765 fields
= zmalloc(nr_fields
* sizeof(*fields
));
769 for (i
= 0; i
< nr_fields
; i
++) {
770 struct ustctl_field
*f
;
771 const struct lttng_event_field
*lf
;
773 f
= &fields
[nr_write_fields
];
774 lf
= <tng_fields
[i
];
776 /* skip 'nowrite' fields */
779 strncpy(f
->name
, lf
->name
, LTTNG_UST_SYM_NAME_LEN
);
780 f
->name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
781 ret
= serialize_one_type(&f
->type
, &lf
->type
);
787 *_nr_write_fields
= nr_write_fields
;
788 *ustctl_fields
= fields
;
797 * Returns 0 on success, negative error value on error.
799 int ustcomm_register_event(int sock
,
800 int session_objd
, /* session descriptor */
801 int channel_objd
, /* channel descriptor */
802 const char *event_name
, /* event name (input) */
804 const char *signature
, /* event signature (input) */
805 size_t nr_fields
, /* fields */
806 const struct lttng_event_field
*lttng_fields
,
807 const char *model_emf_uri
,
808 uint32_t *id
) /* event id (output) */
812 struct ustcomm_notify_hdr header
;
813 struct ustcomm_notify_event_msg m
;
816 struct ustcomm_notify_hdr header
;
817 struct ustcomm_notify_event_reply r
;
819 size_t signature_len
, fields_len
, model_emf_uri_len
;
820 struct ustctl_field
*fields
;
821 size_t nr_write_fields
= 0;
824 memset(&msg
, 0, sizeof(msg
));
825 msg
.header
.notify_cmd
= USTCTL_NOTIFY_CMD_EVENT
;
826 msg
.m
.session_objd
= session_objd
;
827 msg
.m
.channel_objd
= channel_objd
;
828 strncpy(msg
.m
.event_name
, event_name
, LTTNG_UST_SYM_NAME_LEN
);
829 msg
.m
.event_name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
830 msg
.m
.loglevel
= loglevel
;
831 signature_len
= strlen(signature
) + 1;
832 msg
.m
.signature_len
= signature_len
;
834 /* Calculate fields len, serialize fields. */
836 ret
= serialize_fields(&nr_write_fields
, &fields
,
837 nr_fields
, lttng_fields
);
842 fields_len
= sizeof(*fields
) * nr_write_fields
;
843 msg
.m
.fields_len
= fields_len
;
845 model_emf_uri_len
= strlen(model_emf_uri
) + 1;
847 model_emf_uri_len
= 0;
849 msg
.m
.model_emf_uri_len
= model_emf_uri_len
;
850 len
= ustcomm_send_unix_sock(sock
, &msg
, sizeof(msg
));
851 if (len
> 0 && len
!= sizeof(msg
)) {
861 len
= ustcomm_send_unix_sock(sock
, signature
, signature_len
);
862 if (len
> 0 && len
!= signature_len
) {
872 if (fields_len
> 0) {
873 len
= ustcomm_send_unix_sock(sock
, fields
, fields_len
);
875 if (len
> 0 && len
!= fields_len
) {
883 if (model_emf_uri_len
) {
884 /* send model_emf_uri */
885 len
= ustcomm_send_unix_sock(sock
, model_emf_uri
,
887 if (len
> 0 && len
!= model_emf_uri_len
)
894 len
= ustcomm_recv_unix_sock(sock
, &reply
, sizeof(reply
));
896 case 0: /* orderly shutdown */
899 if (reply
.header
.notify_cmd
!= msg
.header
.notify_cmd
) {
900 ERR("Unexpected result message command "
901 "expected: %u vs received: %u\n",
902 msg
.header
.notify_cmd
, reply
.header
.notify_cmd
);
905 if (reply
.r
.ret_code
> 0)
907 if (reply
.r
.ret_code
< 0)
908 return reply
.r
.ret_code
;
909 *id
= reply
.r
.event_id
;
910 DBG("Sent register event notification for name \"%s\": ret_code %d, event_id %u\n",
911 event_name
, reply
.r
.ret_code
, reply
.r
.event_id
);
915 /* Transport level error */
916 if (errno
== EPIPE
|| errno
== ECONNRESET
)
920 ERR("incorrect message size: %zd\n", len
);
927 * Returns 0 on success, negative error value on error.
928 * Returns -EPIPE or -ECONNRESET if other end has hung up.
930 int ustcomm_register_channel(int sock
,
931 int session_objd
, /* session descriptor */
932 int channel_objd
, /* channel descriptor */
933 size_t nr_ctx_fields
,
934 const struct lttng_event_field
*ctx_fields
,
935 uint32_t *chan_id
, /* channel id (output) */
936 int *header_type
) /* header type (output) */
940 struct ustcomm_notify_hdr header
;
941 struct ustcomm_notify_channel_msg m
;
944 struct ustcomm_notify_hdr header
;
945 struct ustcomm_notify_channel_reply r
;
948 struct ustctl_field
*fields
;
950 size_t nr_write_fields
= 0;
952 memset(&msg
, 0, sizeof(msg
));
953 msg
.header
.notify_cmd
= USTCTL_NOTIFY_CMD_CHANNEL
;
954 msg
.m
.session_objd
= session_objd
;
955 msg
.m
.channel_objd
= channel_objd
;
957 /* Calculate fields len, serialize fields. */
958 if (nr_ctx_fields
> 0) {
959 ret
= serialize_fields(&nr_write_fields
, &fields
,
960 nr_ctx_fields
, ctx_fields
);
965 fields_len
= sizeof(*fields
) * nr_write_fields
;
966 msg
.m
.ctx_fields_len
= fields_len
;
967 len
= ustcomm_send_unix_sock(sock
, &msg
, sizeof(msg
));
968 if (len
> 0 && len
!= sizeof(msg
)) {
978 if (fields_len
> 0) {
979 len
= ustcomm_send_unix_sock(sock
, fields
, fields_len
);
981 if (len
> 0 && len
!= fields_len
) {
989 len
= ustcomm_recv_unix_sock(sock
, &reply
, sizeof(reply
));
991 case 0: /* orderly shutdown */
994 if (reply
.header
.notify_cmd
!= msg
.header
.notify_cmd
) {
995 ERR("Unexpected result message command "
996 "expected: %u vs received: %u\n",
997 msg
.header
.notify_cmd
, reply
.header
.notify_cmd
);
1000 if (reply
.r
.ret_code
> 0)
1002 if (reply
.r
.ret_code
< 0)
1003 return reply
.r
.ret_code
;
1004 *chan_id
= reply
.r
.chan_id
;
1005 switch (reply
.r
.header_type
) {
1008 *header_type
= reply
.r
.header_type
;
1011 ERR("Unexpected channel header type %u\n",
1012 reply
.r
.header_type
);
1015 DBG("Sent register channel notification: chan_id %d, header_type %d\n",
1016 reply
.r
.chan_id
, reply
.r
.header_type
);
1020 /* Transport level error */
1021 if (errno
== EPIPE
|| errno
== ECONNRESET
)
1025 ERR("incorrect message size: %zd\n", len
);
1032 * Set socket reciving timeout.
1034 int ustcomm_setsockopt_rcv_timeout(int sock
, unsigned int msec
)
1039 tv
.tv_sec
= msec
/ 1000;
1040 tv
.tv_usec
= (msec
* 1000 % 1000000);
1042 ret
= setsockopt(sock
, SOL_SOCKET
, SO_RCVTIMEO
, &tv
, sizeof(tv
));
1044 PERROR("setsockopt SO_RCVTIMEO");
1052 * Set socket sending timeout.
1054 int ustcomm_setsockopt_snd_timeout(int sock
, unsigned int msec
)
1059 tv
.tv_sec
= msec
/ 1000;
1060 tv
.tv_usec
= (msec
* 1000) % 1000000;
1062 ret
= setsockopt(sock
, SOL_SOCKET
, SO_SNDTIMEO
, &tv
, sizeof(tv
));
1064 PERROR("setsockopt SO_SNDTIMEO");