Lines Matching refs:block
45 * Block cursor - used when processing the contents of a block.
47 * of bytes remaining in the block.
62 pcap_ng_block_header_ptr(pcapng_block_t block)
64 return (block->pcapng_bufptr);
68 pcap_ng_block_fields_ptr(pcapng_block_t block)
70 return (block->pcapng_bufptr +
75 pcap_ng_block_data_ptr(pcapng_block_t block)
77 if (block->pcapng_data_is_external)
78 return (block->pcapng_data_ptr);
80 return (block->pcapng_bufptr +
82 block->pcapng_fields_len);
86 pcap_ng_block_records_ptr(pcapng_block_t block)
88 if (block->pcapng_block_type != PCAPNG_BT_NRB)
91 if (block->pcapng_data_is_external)
92 return (block->pcapng_bufptr +
94 block->pcapng_fields_len);
96 return (block->pcapng_bufptr +
98 block->pcapng_fields_len +
99 block->pcapng_data_len);
103 pcap_ng_block_options_ptr(pcapng_block_t block)
105 if (block->pcapng_block_type == PCAPNG_BT_SPB)
108 if (block->pcapng_data_is_external)
109 return (block->pcapng_bufptr +
111 block->pcapng_fields_len +
112 block->pcapng_records_len);
114 return (block->pcapng_bufptr +
116 block->pcapng_fields_len +
117 block->pcapng_data_len +
118 block->pcapng_records_len);
122 pcap_ng_block_trailer_ptr(pcapng_block_t block)
124 if (block->pcapng_data_is_external)
125 return (block->pcapng_bufptr +
127 block->pcapng_fields_len +
128 block->pcapng_records_len +
129 block->pcapng_options_len);
131 return (block->pcapng_bufptr +
133 block->pcapng_fields_len +
134 block->pcapng_data_len +
135 block->pcapng_records_len +
136 block->pcapng_options_len);
144 struct pcapng_block *block;
147 * The internal block structure is prepended
154 block = (struct pcapng_block *)ptr;
155 bzero(block, sizeof(struct pcapng_block));
157 block->pcapng_bufptr = ptr + PAD_64BIT(sizeof(struct pcapng_block));
158 block->pcapng_buflen = len;
161 return (block);
165 pcap_ng_free_block(pcapng_block_t block)
167 free(block);
171 pcap_ng_block_get_type(pcapng_block_t block)
173 return (block->pcapng_block_type);
177 pcap_ng_block_get_len(pcapng_block_t block)
179 return (block->pcapng_block_len);
183 pcap_ng_block_is_swapped(pcapng_block_t block)
185 return (block->pcapng_block_swapped);
189 pcapng_update_block_length(pcapng_block_t block)
191 block->pcapng_block_len = sizeof(struct pcapng_block_header) +
192 block->pcapng_fields_len +
193 block->pcapng_data_len +
194 block->pcapng_records_len +
195 block->pcapng_options_len +
198 if (block->pcapng_block_len > block->pcapng_buflen) {
199 errx(EX_SOFTWARE, "%s block len %lu greater than buffer size %lu",
200 __func__, block->pcapng_block_len, block->pcapng_buflen);
208 pcap_ng_block_reset(pcapng_block_t block, bpf_u_int32 type)
210 bzero(&block->block_fields_, sizeof(block->block_fields_));
214 block->pcapng_block_type = type;
216 block->pcap_ng_shb_fields.byte_order_magic = PCAPNG_BYTE_ORDER_MAGIC;
217 block->pcap_ng_shb_fields.major_version = PCAPNG_VERSION_MAJOR;
218 block->pcap_ng_shb_fields.minor_version = PCAPNG_VERSION_MINOR;
219 block->pcap_ng_shb_fields.section_length = (uint64_t)-1;
221 block->pcapng_fields_len = sizeof(struct pcapng_section_header_fields);
225 block->pcapng_block_type = type;
227 block->pcapng_fields_len = sizeof(struct pcapng_interface_description_fields);
231 block->pcapng_block_type = type;
233 block->pcapng_fields_len = sizeof(struct pcapng_packet_fields);
238 block->pcapng_block_type = type;
240 block->pcapng_fields_len = sizeof(struct pcapng_simple_packet_fields);
245 block->pcapng_block_type = type;
247 block->pcapng_fields_len = 0;
251 block->pcapng_block_type = type;
253 block->pcapng_fields_len = sizeof(struct pcapng_interface_statistics_fields);
257 block->pcapng_block_type = type;
259 block->pcapng_fields_len = sizeof(struct pcapng_enhanced_packet_fields);
263 block->pcapng_block_type = type;
265 block->pcapng_fields_len = sizeof(struct pcapng_process_information_fields);
272 block->pcapng_data_ptr = NULL;
273 block->pcapng_data_len = 0;
274 block->pcapng_cap_len = 0;
275 block->pcapng_data_is_external = 0;
277 block->pcapng_records_len = 0;
279 block->pcapng_options_len = 0;
281 pcapng_update_block_length(block);
287 pcap_ng_get_section_header_fields(pcapng_block_t block)
289 if (block != NULL && block->pcapng_block_type == PCAPNG_BT_SHB)
290 return &block->pcap_ng_shb_fields;
296 pcap_ng_get_interface_description_fields(pcapng_block_t block)
298 if (block != NULL && block->pcapng_block_type == PCAPNG_BT_IDB)
299 return &block->pcap_ng_idb_fields;
305 pcap_ng_get_enhanced_packet_fields(pcapng_block_t block)
307 if (block != NULL && block->pcapng_block_type == PCAPNG_BT_EPB)
308 return &block->pcap_ng_epb_fields;
314 pcap_ng_get_simple_packet_fields(pcapng_block_t block)
316 if (block != NULL && block->pcapng_block_type == PCAPNG_BT_SPB)
317 return &block->pcap_ng_spb_fields;
323 pcap_ng_get_packet_fields(pcapng_block_t block)
325 if (block != NULL && block->pcapng_block_type == PCAPNG_BT_PB)
326 return &block->pcap_ng_opb_fields;
332 pcap_ng_get_interface_statistics_fields(pcapng_block_t block)
334 if (block != NULL && block->pcapng_block_type == PCAPNG_BT_ISB)
335 return &block->pcap_ng_isb_fields;
341 pcap_ng_get_process_information_fields(pcapng_block_t block)
343 if (block != NULL && block->pcapng_block_type == PCAPNG_BT_PIB)
344 return &block->pcap_ng_pib_fields;
350 pcap_ng_block_does_support_data(pcapng_block_t block)
352 switch (block->pcapng_block_type) {
366 pcap_ng_block_packet_get_data_ptr(pcapng_block_t block)
368 if (pcap_ng_block_does_support_data(block) == 0)
371 return (block->pcapng_data_ptr);
375 pcap_ng_block_packet_get_data_len(pcapng_block_t block)
377 if (pcap_ng_block_does_support_data(block) == 0)
380 return (block->pcapng_cap_len);
384 pcap_ng_block_packet_copy_data(pcapng_block_t block, const void *ptr,
389 if (pcap_ng_block_does_support_data(block) == 0)
392 if (block->pcapng_block_len + PAD_32BIT(caplen) > block->pcapng_buflen) {
393 warnx("%s block len %lu greater than buffer size %lu",
394 __func__, block->pcapng_block_len, block->pcapng_buflen);
400 if (block->pcapng_records_len > 0 || block->pcapng_options_len > 0) {
401 u_char *tmp = pcap_ng_block_records_ptr(block) ?
402 pcap_ng_block_records_ptr(block) :
403 pcap_ng_block_options_ptr(block);
404 size_t len = block->pcapng_records_len + block->pcapng_options_len;
405 int32_t offset = PAD_32BIT(caplen) - block->pcapng_data_len;
413 block->pcapng_data_is_external = 0;
414 block->pcapng_data_ptr = pcap_ng_block_data_ptr(block);
415 bcopy(ptr, block->pcapng_data_ptr, caplen);
417 bzero(block->pcapng_data_ptr + caplen, padding_len);
418 block->pcapng_cap_len = caplen;
419 block->pcapng_data_len = PAD_32BIT(caplen);
421 pcapng_update_block_length(block);
427 pcap_ng_block_packet_set_data(pcapng_block_t block, const void *ptr,
430 if (pcap_ng_block_does_support_data(block) == 0)
433 block->pcapng_data_is_external = 1;
434 block->pcapng_data_ptr = (u_char *)ptr;
435 block->pcapng_cap_len = caplen;
436 block->pcapng_data_len = PAD_32BIT(caplen);
438 pcapng_update_block_length(block);
444 pcap_ng_block_add_option_with_value(pcapng_block_t block, u_short code,
451 u_char *block_option_ptr = pcap_ng_block_options_ptr(block);
454 warnx("%s options not supported for block type %u",
455 __func__, block->pcapng_block_type);
459 if (optlen + block->pcapng_block_len > block->pcapng_buflen) {
460 warnx("%s block len %lu greater than buffer size %lu",
461 __func__, block->pcapng_block_len, block->pcapng_buflen);
465 opt_header = (struct pcapng_option_header *)(block_option_ptr + block->pcapng_options_len);
467 if (block->pcapng_options_len > 0)
480 if (block->pcapng_options_len == 0)
481 block->pcapng_options_len = sizeof(struct pcapng_option_header);
483 block->pcapng_options_len += optlen;
486 opt_header = (struct pcapng_option_header *)(block_option_ptr + block->pcapng_options_len);
491 pcapng_update_block_length(block);
497 pcap_ng_block_add_option_with_string(pcapng_block_t block, u_short code, const char *str)
499 return (pcap_ng_block_add_option_with_value(block, code, str, strlen(str) + 1));
551 pcap_ng_block_get_option(pcapng_block_t block, u_short code, struct pcapng_option_info *option_info)
560 if (block->pcapng_options_len == 0)
563 swapped = block->pcapng_block_swapped;
565 cursor.block_type = block->pcapng_block_type;
566 cursor.data = pcap_ng_block_options_ptr(block);
567 cursor.data_remaining = block->pcapng_options_len;
598 pcnapng_block_iterate_options(pcapng_block_t block,
607 if (block == NULL || opt_iterator_func == NULL)
609 swapped = block->pcapng_block_swapped;
611 cursor.block_type = block->pcapng_block_type;
612 cursor.data = pcap_ng_block_options_ptr(block);
613 cursor.data_remaining = block->pcapng_options_len;
631 opt_iterator_func(block, &option_info, context);
645 pcnapng_block_iterate_name_records(pcapng_block_t block,
654 if (block == NULL || record_iterator_func == NULL)
656 swapped = block->pcapng_block_swapped;
658 cursor.block_type = block->pcapng_block_type;
659 cursor.data = pcap_ng_block_records_ptr(block);
660 cursor.data_remaining = block->pcapng_records_len;
698 pcap_ng_block_add_name_record_common(pcapng_block_t block, uint32_t type,
709 u_char *block_records_ptr = pcap_ng_block_records_ptr(block);
722 if (record_len + block->pcapng_block_len > block->pcapng_buflen) {
723 warnx("%s block len %lu greater than buffer size %lu",
724 __func__, block->pcapng_block_len, block->pcapng_buflen);
731 if (block->pcapng_options_len > 0) {
732 u_char *tmp = pcap_ng_block_options_ptr(block);
734 bcopy(tmp, tmp + record_len, block->pcapng_options_len);
739 record_hdr = (struct pcapng_record_header*)(block_records_ptr + block->pcapng_records_len);
740 if (block->pcapng_records_len > 0)
759 block->pcapng_records_len += record_len;
761 pcapng_update_block_length(block);
767 pcap_ng_block_add_name_record_with_ip4(pcapng_block_t block,
771 if (block->pcapng_block_type != PCAPNG_BT_NRB)
774 return pcap_ng_block_add_name_record_common(block,
782 pcap_ng_block_add_name_record_with_ip6(pcapng_block_t block,
786 if (block->pcapng_block_type != PCAPNG_BT_NRB)
789 return pcap_ng_block_add_name_record_common(block,
797 pcap_ng_externalize_block(void *buffer, size_t buflen, pcapng_block_t block)
804 if (buffer == NULL || buflen < block->pcapng_block_len)
808 block_header.block_type = block->pcapng_block_type;
809 block_header.total_length = block->pcapng_block_len;
813 switch (block->pcapng_block_type) {
822 if (block->pcapng_block_type == PCAPNG_BT_PB) {
823 if(block->pcap_ng_opb_fields.caplen == 0)
824 block->pcap_ng_opb_fields.caplen = block->pcapng_cap_len;
825 if(block->pcap_ng_opb_fields.len == 0)
826 block->pcap_ng_opb_fields.len = block->pcapng_cap_len;
828 if (block->pcapng_block_type == PCAPNG_BT_SPB) {
829 if(block->pcap_ng_spb_fields.len == 0)
830 block->pcap_ng_spb_fields.len = block->pcapng_cap_len;
832 if (block->pcapng_block_type == PCAPNG_BT_EPB) {
833 if(block->pcap_ng_epb_fields.caplen == 0)
834 block->pcap_ng_epb_fields.caplen = block->pcapng_cap_len;
835 if(block->pcap_ng_epb_fields.len == 0)
836 block->pcap_ng_epb_fields.len = block->pcapng_cap_len;
839 if (block->pcapng_fields_len > 0) {
840 bcopy(&block->pcap_ng_shb_fields, ptr + bytes_written, block->pcapng_fields_len);
841 bytes_written += block->pcapng_fields_len;
845 /* Unknown block */
851 if (block->pcapng_data_len > 0) {
852 bpf_u_int32 padding_len = PAD_32BIT(block->pcapng_cap_len) - block->pcapng_cap_len;
854 bcopy(block->pcapng_data_ptr, ptr + bytes_written, block->pcapng_cap_len);
855 bytes_written += block->pcapng_cap_len;
863 if (block->pcapng_records_len > 0) {
864 bcopy(pcap_ng_block_records_ptr(block), ptr + bytes_written, block->pcapng_records_len);
865 bytes_written += block->pcapng_records_len;
867 if (block->pcapng_options_len > 0) {
868 bcopy(pcap_ng_block_options_ptr(block), ptr + bytes_written, block->pcapng_options_len);
869 bytes_written += block->pcapng_options_len;
872 block_trailer.total_length = block->pcapng_block_len;
880 pcap_ng_dump_block(pcap_dumper_t *p, pcapng_block_t block)
889 block_header = (struct pcapng_block_header *)pcap_ng_block_header_ptr(block);
890 block_header->block_type = block->pcapng_block_type;
891 block_header->total_length = block->pcapng_block_len;
893 switch (block->pcapng_block_type) {
902 if (block->pcapng_block_type == PCAPNG_BT_PB) {
903 if(block->pcap_ng_opb_fields.caplen == 0)
904 block->pcap_ng_opb_fields.caplen = block->pcapng_cap_len;
905 if(block->pcap_ng_opb_fields.len == 0)
906 block->pcap_ng_opb_fields.len = block->pcapng_cap_len;
908 if (block->pcapng_block_type == PCAPNG_BT_SPB) {
909 if(block->pcap_ng_spb_fields.len == 0)
910 block->pcap_ng_spb_fields.len = block->pcapng_cap_len;
912 if (block->pcapng_block_type == PCAPNG_BT_EPB) {
913 if(block->pcap_ng_epb_fields.caplen == 0)
914 block->pcap_ng_epb_fields.caplen = block->pcapng_cap_len;
915 if(block->pcap_ng_epb_fields.len == 0)
916 block->pcap_ng_epb_fields.len = block->pcapng_cap_len;
919 if (block->pcapng_fields_len > 0)
920 bcopy(&block->pcap_ng_shb_fields, pcap_ng_block_fields_ptr(block), block->pcapng_fields_len);
923 /* Unknown block */
928 block_trailer = pcap_ng_block_trailer_ptr(block);
932 iov[iovcnt].iov_len = sizeof(struct pcapng_block_header) + block->pcapng_fields_len;
933 iov[iovcnt].iov_base = block->pcapng_bufptr;
936 if (block->pcapng_data_len > 0) {
937 bpf_u_int32 padding_len = PAD_32BIT(block->pcapng_cap_len) - block->pcapng_cap_len;
939 iov[iovcnt].iov_len = block->pcapng_cap_len;
940 iov[iovcnt].iov_base = block->pcapng_data_ptr;
951 * The name records, options and block trailer are contiguous
953 iov[iovcnt].iov_len = block->pcapng_records_len +
954 block->pcapng_options_len +
956 if (block->pcapng_records_len > 0)
957 iov[iovcnt].iov_base = pcap_ng_block_records_ptr(block);
958 else if (block->pcapng_options_len > 0)
959 iov[iovcnt].iov_base = pcap_ng_block_options_ptr(block);
972 pcapng_block_t block = NULL;
1002 "%s: Unknown block type length %u",
1015 * Some ntar files from wireshark.org do not round up the total block length to
1016 * a multiple of 4 bytes -- they must ignore the 32 bit alignment of the block body!
1021 block = pcap_ng_block_alloc(bh.total_length);
1022 if (block == NULL) {
1024 "%s: Unknown block type %u",
1029 block = *pblock;
1031 block->pcapng_bufptr = raw_block;
1032 block->pcapng_buflen = bh.total_length;
1033 block->pcapng_buf_is_external = 1;
1034 pcap_ng_block_reset(block, bh.block_type);
1035 block->pcapng_block_len = bh.total_length;
1036 block->pcapng_block_swapped = swapped;
1046 struct pcapng_section_header_fields *shbp = pcap_ng_get_section_header_fields(block);
1067 struct pcapng_interface_description_fields *idbp = pcap_ng_get_interface_description_fields(block);
1086 struct pcapng_interface_statistics_fields *isbp = pcap_ng_get_interface_statistics_fields(block);
1105 struct pcapng_enhanced_packet_fields *epbp = pcap_ng_get_enhanced_packet_fields(block);
1128 block->pcapng_data_is_external = 0;
1129 block->pcapng_data_ptr = (u_char *)data;
1130 block->pcapng_cap_len = epbp->caplen;
1131 block->pcapng_data_len = PAD_32BIT(epbp->caplen);
1136 struct pcapng_simple_packet_fields *spbp = pcap_ng_get_simple_packet_fields(block);
1156 block->pcapng_data_is_external = 0;
1157 block->pcapng_data_ptr = (u_char *)data;
1158 block->pcapng_cap_len = caplen;
1159 block->pcapng_data_len = PAD_32BIT(caplen);
1164 struct pcapng_packet_fields *pbp = pcap_ng_get_packet_fields(block);
1191 block->pcapng_data_is_external = 0;
1192 block->pcapng_data_ptr = (u_char *)data;
1193 block->pcapng_cap_len = pbp->caplen;
1194 block->pcapng_data_len = PAD_32BIT(pbp->caplen);
1199 struct pcapng_process_information_fields *pibp = pcap_ng_get_process_information_fields(block);
1213 struct pcapng_record_header *rh = (struct pcapng_record_header *)(block + 1);
1230 block->pcapng_records_len += sizeof(struct pcapng_record_header) +
1264 block->pcapng_options_len += sizeof(struct pcapng_option_header) + PCAPNG_ROUNDUP32(optlen);
1272 *pblock = block;
1276 if (*pblock == NULL && block != NULL)
1277 pcap_ng_free_block(block);
1282 pcap_ng_block_init_with_raw_block(pcapng_block_t block, pcap_t *p, u_char *raw_block)
1284 return pcap_ng_block_internalize_common(&block, p, raw_block);
1290 pcapng_block_t block = NULL;
1292 if (pcap_ng_block_internalize_common(&block, p, raw_block) == 0)
1293 return (block);