+/* Open a connection to a traceable app.
+ *
+ * Return value:
+ * 0: success
+ * -1: error
+ */
+
+int ustcomm_connect_app(pid_t pid, int *app_fd)
+{
+ int result;
+ int retval = 0;
+ char *name;
+
+ result = asprintf(&name, "%s/%d", SOCK_DIR, pid);
+ if (result < 0) {
+ ERR("failed to allocate socket name");
+ return -1;
+ }
+
+ result = ustcomm_connect_path(name, app_fd);
+ if (result < 0) {
+ ERR("failed to connect to app");
+ retval = -1;
+ }
+
+ free(name);
+
+ return retval;
+}
+
+int ensure_dir_exists(const char *dir)
+{
+ struct stat st;
+ int result;
+
+ if(!strcmp(dir, ""))
+ return -1;
+
+ result = stat(dir, &st);
+ if(result == -1 && errno != ENOENT) {
+ return -1;
+ }
+ else if(result == -1) {
+ /* ENOENT */
+ int result;
+
+ /* mkdir mode to 0777 */
+ result = mkdir_p(dir, S_IRWXU | S_IRWXG | S_IRWXO);
+ if(result != 0) {
+ ERR("executing in recursive creation of directory %s", dir);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+char * ustcomm_print_data(char *data_field, int field_size,
+ int *offset, const char *format, ...)
+{
+ va_list args;
+ int count, limit;
+ char *ptr = USTCOMM_POISON_PTR;
+
+ limit = field_size - *offset;
+ va_start(args, format);
+ count = vsnprintf(&data_field[*offset], limit, format, args);
+ va_end(args);
+
+ if (count < limit && count > -1) {
+ ptr = NULL + *offset;
+ *offset = *offset + count + 1;
+ }
+
+ return ptr;
+}
+
+char * ustcomm_restore_ptr(char *ptr, char *data_field, int data_field_size)
+{
+ if ((unsigned long)ptr > data_field_size ||
+ ptr == USTCOMM_POISON_PTR) {
+ return NULL;
+ }
+
+ return data_field + (long)ptr;
+}
+
+int ustcomm_pack_trace_info(struct ustcomm_header *header,
+ struct ustcomm_trace_info *trace_inf,
+ const char *trace)
+{
+ int offset = 0;
+
+ trace_inf->trace = ustcomm_print_data(trace_inf->data,
+ sizeof(trace_inf->data),
+ &offset,
+ trace);
+
+ if (trace_inf->trace == USTCOMM_POISON_PTR) {
+ return -ENOMEM;
+ }
+
+ header->size = COMPUTE_MSG_SIZE(trace_inf, offset);
+
+ return 0;
+}
+
+
+int ustcomm_unpack_trace_info(struct ustcomm_trace_info *trace_inf)
+{
+ trace_inf->trace = ustcomm_restore_ptr(trace_inf->trace,
+ trace_inf->data,
+ sizeof(trace_inf->data));
+ if (!trace_inf->trace) {
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+int ustcomm_pack_channel_info(struct ustcomm_header *header,
+ struct ustcomm_channel_info *ch_inf,
+ const char *trace,
+ const char *channel)
+{
+ int offset = 0;
+
+ ch_inf->trace = ustcomm_print_data(ch_inf->data,
+ sizeof(ch_inf->data),
+ &offset,
+ trace);
+
+ if (ch_inf->trace == USTCOMM_POISON_PTR) {
+ return -ENOMEM;
+ }
+
+ ch_inf->channel = ustcomm_print_data(ch_inf->data,
+ sizeof(ch_inf->data),
+ &offset,
+ channel);
+
+ if (ch_inf->channel == USTCOMM_POISON_PTR) {
+ return -ENOMEM;
+ }
+
+ header->size = COMPUTE_MSG_SIZE(ch_inf, offset);
+
+ return 0;
+}
+
+
+int ustcomm_unpack_channel_info(struct ustcomm_channel_info *ch_inf)
+{
+ ch_inf->trace = ustcomm_restore_ptr(ch_inf->trace,
+ ch_inf->data,
+ sizeof(ch_inf->data));
+ if (!ch_inf->trace) {
+ return -EINVAL;
+ }
+
+ ch_inf->channel = ustcomm_restore_ptr(ch_inf->channel,
+ ch_inf->data,
+ sizeof(ch_inf->data));
+ if (!ch_inf->channel) {
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+int ustcomm_pack_buffer_info(struct ustcomm_header *header,
+ struct ustcomm_buffer_info *buf_inf,
+ const char *trace,
+ const char *channel,
+ int channel_cpu)
+{
+ int offset = 0;
+
+ buf_inf->trace = ustcomm_print_data(buf_inf->data,
+ sizeof(buf_inf->data),
+ &offset,
+ trace);
+
+ if (buf_inf->trace == USTCOMM_POISON_PTR) {
+ return -ENOMEM;
+ }
+
+ buf_inf->channel = ustcomm_print_data(buf_inf->data,
+ sizeof(buf_inf->data),
+ &offset,
+ channel);
+
+ if (buf_inf->channel == USTCOMM_POISON_PTR) {
+ return -ENOMEM;
+ }
+
+ buf_inf->ch_cpu = channel_cpu;
+
+ header->size = COMPUTE_MSG_SIZE(buf_inf, offset);
+
+ return 0;
+}
+
+
+int ustcomm_unpack_buffer_info(struct ustcomm_buffer_info *buf_inf)
+{
+ buf_inf->trace = ustcomm_restore_ptr(buf_inf->trace,
+ buf_inf->data,
+ sizeof(buf_inf->data));
+ if (!buf_inf->trace) {
+ return -EINVAL;
+ }
+
+ buf_inf->channel = ustcomm_restore_ptr(buf_inf->channel,
+ buf_inf->data,
+ sizeof(buf_inf->data));
+ if (!buf_inf->channel) {
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+int ustcomm_pack_marker_info(struct ustcomm_header *header,
+ struct ustcomm_marker_info *marker_inf,
+ const char *trace,
+ const char *channel,
+ const char *marker)
+{
+ int offset = 0;
+
+ marker_inf->trace = ustcomm_print_data(marker_inf->data,
+ sizeof(marker_inf->data),
+ &offset,
+ trace);
+
+ if (marker_inf->trace == USTCOMM_POISON_PTR) {
+ return -ENOMEM;
+ }
+
+
+ marker_inf->channel = ustcomm_print_data(marker_inf->data,
+ sizeof(marker_inf->data),
+ &offset,
+ channel);
+
+ if (marker_inf->channel == USTCOMM_POISON_PTR) {
+ return -ENOMEM;
+ }
+
+
+ marker_inf->marker = ustcomm_print_data(marker_inf->data,
+ sizeof(marker_inf->data),
+ &offset,
+ marker);
+
+ if (marker_inf->marker == USTCOMM_POISON_PTR) {
+ return -ENOMEM;
+ }
+
+ header->size = COMPUTE_MSG_SIZE(marker_inf, offset);
+
+ return 0;
+}
+
+int ustcomm_unpack_marker_info(struct ustcomm_marker_info *marker_inf)
+{
+ marker_inf->trace = ustcomm_restore_ptr(marker_inf->trace,
+ marker_inf->data,
+ sizeof(marker_inf->data));
+ if (!marker_inf->trace) {
+ return -EINVAL;
+ }
+
+ marker_inf->channel = ustcomm_restore_ptr(marker_inf->channel,
+ marker_inf->data,
+ sizeof(marker_inf->data));
+ if (!marker_inf->channel) {
+ return -EINVAL;
+ }
+
+ marker_inf->marker = ustcomm_restore_ptr(marker_inf->marker,
+ marker_inf->data,
+ sizeof(marker_inf->data));
+ if (!marker_inf->marker) {
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+int ustcomm_pack_sock_path(struct ustcomm_header *header,
+ struct ustcomm_sock_path *sock_path_inf,
+ const char *socket_path)
+{
+ int offset = 0;
+
+ sock_path_inf->sock_path =
+ ustcomm_print_data(sock_path_inf->data,
+ sizeof(sock_path_inf->data),
+ &offset,
+ socket_path);
+
+ if (sock_path_inf->sock_path == USTCOMM_POISON_PTR) {
+ return -ENOMEM;
+ }
+
+ header->size = COMPUTE_MSG_SIZE(sock_path_inf, offset);
+
+ return 0;
+}
+
+int ustcomm_unpack_sock_path(struct ustcomm_sock_path *sock_path_inf)
+{
+ sock_path_inf->sock_path =
+ ustcomm_restore_ptr(sock_path_inf->sock_path,
+ sock_path_inf->data,
+ sizeof(sock_path_inf->data));
+ if (!sock_path_inf->sock_path) {
+ return -EINVAL;
+ }
+
+ return 0;
+}
+