/*! \fn void mpegEncapSetPacketHeader(encap_out_stream_t *out_stream, Uint8* mac_src_addr, Uint8* mac_dst_addr, Uint32 ip4_src_addr, Uint32 ip4_dst_addr, Uint16 udp_src_port, Uint16 udp_dst_port, encapHeaderType_e encap_type, udpCsum_e udp_csum, Uint32 rtp_ssrc) ************************************************************************** * \brief Set Mpeg Encap IP packet header API * \return 0 or error code */ void mpegEncapSetPacketHeader(encap_out_stream_t *out_stream, Uint8* mac_src_addr, Uint8* mac_dst_addr, Uint32 ip4_src_addr, Uint32 ip4_dst_addr, Uint16 udp_src_port, Uint16 udp_dst_port, encapHeaderType_e encap_type, udpCsum_e udp_csum, Uint32 rtp_ssrc) { memcpy(out_stream->eth_dst_addr, mac_dst_addr, ETH_ALEN); out_stream->ip_id = 0; out_stream->rtp_seq_num = 0; out_stream->pcr2pcr_frames_counter = -1; out_stream->old_sysclk = 0; out_stream->old_90K_clk = 0; set_packet_header(&(out_stream->encap_header), mac_src_addr, mac_dst_addr, ip4_src_addr, ip4_dst_addr, udp_src_port, udp_dst_port, rtp_ssrc); out_stream->encap_header_type = encap_type; out_stream->udp_csum = udp_csum; out_stream->encap_frame_headers_size = sizeof(out_stream->encap_header.eth_header) + sizeof(out_stream->encap_header.ip_header) + sizeof(out_stream->encap_header.udp_header); if (MPEG_ENCAP_RTP_HEADER==out_stream->encap_header_type) out_stream->encap_frame_headers_size += sizeof(out_stream->encap_header.rtp_header); }
static void set_hf_send_packet(int fd_out, int fd_in, unsigned char buffer[], unsigned char len, unsigned char *seq, unsigned char type, unsigned char response[], int *response_length) { set_packet_header(buffer, len, *seq, type); crc_packet(tabel, buffer, len); send_packet(fd_out, fd_in, buffer, len + 2, response, response_length); increment_counter(seq); }
static void format_packet(struct strbuf *out, const char *fmt, va_list args) { size_t orig_len, n; orig_len = out->len; strbuf_addstr(out, "0000"); strbuf_vaddf(out, fmt, args); n = out->len - orig_len; if (n > LARGE_PACKET_MAX) die("protocol error: impossibly long line"); set_packet_header(&out->buf[orig_len], n); packet_trace(out->buf + orig_len + 4, n - 4, 1); }
static int packet_write_gently(const int fd_out, const char *buf, size_t size) { static char packet_write_buffer[LARGE_PACKET_MAX]; size_t packet_size; if (size > sizeof(packet_write_buffer) - 4) return error("packet write failed - data exceeds max packet size"); packet_trace(buf, size, 1); packet_size = size + 4; set_packet_header(packet_write_buffer, packet_size); memcpy(packet_write_buffer + 4, buf, size); if (write_in_full(fd_out, packet_write_buffer, packet_size) == packet_size) return 0; return error("packet write failed"); }
BT_HIDDEN struct bt_ctf_stream *bt_ctf_stream_create( struct bt_ctf_stream_class *stream_class, struct bt_ctf_trace *trace) { int ret; struct bt_ctf_stream *stream = NULL; if (!stream_class || !trace) { goto end; } stream = g_new0(struct bt_ctf_stream, 1); if (!stream) { goto end; } /* A stream has no ownership of its trace (weak ptr) */ stream->trace = trace; bt_object_init(stream, bt_ctf_stream_destroy); stream->packet_context = bt_ctf_field_create( stream_class->packet_context_type); if (!stream->packet_context) { goto error; } /* * A stream class may not have a stream event context defined * in which case this stream will never have a stream_event_context * member since, after a stream's creation, the parent stream class * is "frozen" (immutable). */ if (stream_class->event_context_type) { stream->event_context = bt_ctf_field_create( stream_class->event_context_type); if (!stream->packet_context) { goto error; } } /* Initialize events_discarded */ ret = set_structure_field_integer(stream->packet_context, "events_discarded", 0); if (ret) { goto error; } stream->pos.fd = -1; stream->id = stream_class->next_stream_id++; stream->stream_class = stream_class; bt_get(stream_class); stream->events = g_ptr_array_new_with_free_func( (GDestroyNotify) put_event); if (!stream->events) { goto error; } if (stream_class->event_context_type) { stream->event_contexts = g_ptr_array_new_with_free_func( (GDestroyNotify) bt_ctf_field_put); if (!stream->event_contexts) { goto error; } } /* A trace is not allowed to have a NULL packet header */ assert(trace->packet_header_type); stream->packet_header = bt_ctf_field_create(trace->packet_header_type); if (!stream->packet_header) { goto error; } /* * Attempt to populate the default trace packet header fields * (magic, uuid and stream_id). This will _not_ fail shall the * fields not be found or be of an incompatible type; they will * simply not be populated automatically. The user will have to * make sure to set the trace packet header fields himself before * flushing. */ ret = set_packet_header(stream); if (ret) { goto error; } end: return stream; error: BT_PUT(stream); return stream; }
struct bt_ctf_stream *bt_ctf_stream_create( struct bt_ctf_stream_class *stream_class, const char *name) { int ret; struct bt_ctf_stream *stream = NULL; struct bt_ctf_trace *trace = NULL; struct bt_ctf_writer *writer = NULL; if (!stream_class) { goto error; } trace = bt_ctf_stream_class_get_trace(stream_class); if (!trace) { goto error; } stream = g_new0(struct bt_ctf_stream, 1); if (!stream) { goto error; } bt_object_init(stream, bt_ctf_stream_destroy); /* * Acquire reference to parent since stream will become publicly * reachable; it needs its parent to remain valid. */ bt_object_set_parent(stream, trace); stream->id = stream_class->next_stream_id++; stream->stream_class = stream_class; stream->pos.fd = -1; if (name) { stream->name = g_string_new(name); if (!stream->name) { goto error; } } if (trace->is_created_by_writer) { int fd; writer = (struct bt_ctf_writer *) bt_object_get_parent(trace); assert(writer); stream->packet_context = bt_ctf_field_create( stream_class->packet_context_type); if (!stream->packet_context) { goto error; } /* Initialize events_discarded */ ret = set_structure_field_integer(stream->packet_context, "events_discarded", 0); if (ret) { goto error; } stream->events = g_ptr_array_new_with_free_func( (GDestroyNotify) release_event); if (!stream->events) { goto error; } /* A trace is not allowed to have a NULL packet header */ assert(trace->packet_header_type); stream->packet_header = bt_ctf_field_create(trace->packet_header_type); if (!stream->packet_header) { goto error; } /* * Attempt to populate the default trace packet header fields * (magic, uuid and stream_id). This will _not_ fail shall the * fields not be found or be of an incompatible type; they will * simply not be populated automatically. The user will have to * make sure to set the trace packet header fields himself * before flushing. */ ret = set_packet_header(stream); if (ret) { goto error; } /* Create file associated with this stream */ fd = create_stream_file(writer, stream); if (fd < 0) { goto error; } ret = set_stream_fd(stream, fd); if (ret) { goto error; } /* Freeze the writer */ bt_ctf_writer_freeze(writer); } else { /* Non-writer stream indicated by a negative FD */ ret = set_stream_fd(stream, -1); if (ret) { goto error; } stream->clock_values = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, g_free); } /* Add this stream to the trace's streams */ g_ptr_array_add(trace->streams, stream); BT_PUT(trace); BT_PUT(writer); return stream; error: BT_PUT(stream); BT_PUT(trace); BT_PUT(writer); return stream; }