void csv::init_fields() {
_lines = -1;
eod = false;
data_buffer = (char*)malloc(BUF_SIZE);
data_buffer_size = BUF_SIZE;
init_data_buffer();
}
void csv::to_csv(vector<string>& row, string& ret, bool crlf, bool empty_field_to_null) {
unsigned i,j;
init_data_buffer();
for(i = 0; i < row.size(); i++) {
if (i > 0) {
add_char_to_data_buffer(',');
}
if (empty_field_to_null && row[i].size() == 0) {
continue;
}
add_char_to_data_buffer('\"');
for(j = 0; j < row[i].size(); j++) {
char v = row[i].at(j);
if (v == '\"') {
add_char_to_data_buffer(v);
}
add_char_to_data_buffer(v);
}
add_char_to_data_buffer('\"');
}
if (crlf) {
add_char_to_data_buffer('\r');
}
add_char_to_data_buffer('\n');
ret.append(data_buffer);
}
struct data_buffer* gen_stat_packet(char* cmd,uint8_t* type,MEM_POOL* mem_pool)
{
char* table_name = NULL;
char* token = NULL;
uint32_t tblen;
if((table_name = strtok(NULL," ")) == NULL)
return NULL;
tblen = strlen(table_name);
if((token = strtok(NULL," ")) == NULL)
return NULL;
*type = atoi(token);
struct data_buffer *dbuf = init_data_buffer();
size_t data_len = tblen + 5 * sizeof(uint8_t) + MESSAGE_HEAD_LEN + 2*sizeof(uint32_t);
databuf_resize(dbuf, data_len);
//写入数据长度
write_int32(data_len,dbuf);
write_int8(1, dbuf);
write_int8(1, dbuf);
write_int16(MT_CD_STAT, dbuf);
write_int32(0, dbuf);
//timeout
write_int32(0, dbuf);
//拼接协议包
write_int32(tblen,dbuf);
write_bytes((uint8_t*)table_name,tblen,dbuf);
write_int8(*type,dbuf);
return dbuf;
}
struct data_buffer* gen_set_load_threshold_packet(char* cmd,MEM_POOL* mem_pool)
{
struct data_buffer *dbuf = init_data_buffer();
size_t data_len = MESSAGE_HEAD_LEN + 2*sizeof(uint32_t) + sizeof(double);
databuf_resize(dbuf, data_len);
//写入数据长度
write_int32(data_len,dbuf);
write_int8(1, dbuf);
write_int8(1, dbuf);
write_int16(MT_CD_EXE_SET_LOAD_THRESHOLD, dbuf);
write_int32(0, dbuf);
//timeout
write_int32(0, dbuf);
char *value_str = strtok(NULL, " ");
if (!value_str)
return NULL;
double value = atof(value_str);
write_bytes((uint8_t *)&value, sizeof(value), dbuf);
return dbuf;
}
int main(int argc, char *argv[])
{
if (argc != 3) {
fprintf(stderr, "Usage: %s input.pcf output.h\n", argv[0]);
return EXIT_FAILURE;
}
int fd = open(argv[1], O_RDONLY);
struct stat filestat;
fstat(fd, &filestat);
void *fontbuf = mmap(NULL, filestat.st_size, PROT_READ,
MAP_PRIVATE, fd, 0);
handle_pcf(fontbuf);
init_data_buffer();
FILE *file = fopen(argv[2], "w");
output_interesting_cursors(file);
fclose(file);
return EXIT_SUCCESS;
}
struct data_buffer* gen_ensure_index_packet(char* cmd,MEM_POOL* mem_pool)
{
char* table_name = NULL;
char* field_name = NULL;
uint32_t tblen;
uint32_t fdlen;
char* token;
enum index_key_alg index_type;
enum field_types data_type;
if((table_name = strtok(NULL," ")) == NULL)
return NULL;
if((field_name = strtok(NULL," ")) == NULL)
return NULL;
if((token = strtok(NULL," ")) == NULL)
return NULL;
index_type = (index_key_alg)atoi(token);
if(index_type > 0xff)
return NULL;
if((token = strtok(NULL," ")) == NULL)
return NULL;
data_type = (enum field_types)atoi(token);
if(data_type > 0xff)
return NULL;
tblen = strlen(table_name);
fdlen = strlen(field_name);
struct data_buffer *dbuf = init_data_buffer();
size_t data_len = tblen + fdlen + 10 * sizeof(uint8_t) + MESSAGE_HEAD_LEN + 2*sizeof(uint32_t);
databuf_resize(dbuf, data_len);
//写入数据长度
write_int32(data_len,dbuf);
write_int8(1, dbuf);
write_int8(1, dbuf);
write_int16(MT_CD_EXE_INDEX, dbuf);
write_int32(0, dbuf);
//timeout
write_int32(0, dbuf);
//拼接协议包
write_int32(tblen,dbuf);
write_bytes((uint8_t*)table_name,tblen,dbuf);
write_int32(fdlen,dbuf);
write_bytes((uint8_t*)field_name,fdlen,dbuf);
write_int8(index_type,dbuf);
write_int8(data_type,dbuf);
return dbuf;
}
bool csv::next_row(vector<string>& row) {
if (!ds->open()) {
return false;
}
if (!has_more_row()) {
return true;
}
init_data_buffer();
int state = CONTROL;
int column_mode = NO_QUOTED_COLUMN;
for(;;) {
int c = ds->getc(false);
if (c == '\"') {
if ((column_mode == NO_QUOTED_COLUMN && state != CONTROL) || state == QUOTED) {
add_char_to_data_buffer(c);
state = COLUMN;
} else if (state == COLUMN) {
state = QUOTED;
} else if (state == CONTROL) {
state = COLUMN;
column_mode = QUOTED_COLUMN;
}
} else if (c == ',') {
if (column_mode == NO_QUOTED_COLUMN || state == QUOTED) {
flush_field(row);
state = CONTROL;
column_mode = NO_QUOTED_COLUMN;
} else {
add_char_to_data_buffer(c);
}
} else if (c == '\n' || c == EOF) {
if (column_mode == NO_QUOTED_COLUMN || state == QUOTED) {
if (c == '\n' && data_buffer[data_buffer_pos] == '\r') {
data_buffer[data_buffer_pos] = 0;
}
flush_field(row);
return true;
} else if (state == COLUMN && c != EOF) {
add_char_to_data_buffer(c);
} else if (c == EOF) {
eod = true;
return true;
}
} else {
if (state == CONTROL) {
column_mode = NO_QUOTED_COLUMN;
state = COLUMN;
}
add_char_to_data_buffer(c);
}
}
}
struct mile_packet* init_mile_packet(int32_t socket_fd, struct event* event) {
struct mile_packet* packet = (struct mile_packet*) malloc(
sizeof(struct mile_packet));
if (packet == NULL) {
log_error("初始化mile packet时申请内存失败!");
return NULL;
}
packet->socket_fd = socket_fd;
packet->event = event;
packet->launch_time = get_time_usec();
packet->start_process_time = 0;
packet->in_send_queue_time = 0;
packet->out_send_queue_time = 0;
packet->rbuf = init_data_buffer();
packet->sbuf = init_data_buffer();
packet->flags = -1;
INIT_LIST_HEAD(&packet->packet_list);
return packet;
}
int
main (int argc, char **argv)
{
int index;
int status = 0;
set_program_name (argv[0]);
if (getuid () == 0)
is_root = true;
/* Parse command line */
iu_argp_init ("ping6", program_authors);
argp_parse (&argp, argc, argv, 0, &index, NULL);
ping = ping_init (0, getpid ());
if (ping == NULL)
/* ping_init() prints our error message. */
exit (1);
setsockopt (ping->ping_fd, SOL_SOCKET, SO_BROADCAST, (char *) &one, sizeof (one));
/* Reset root privileges */
setuid (getuid ());
argc -= index;
argv += index;
if (count != 0)
ping_set_count (ping, count);
if (socket_type != 0)
ping_set_sockopt (ping, socket_type, &one, sizeof (one));
if (options & OPT_INTERVAL)
ping_set_interval (ping, interval);
init_data_buffer (patptr, pattern_len);
while (argc--)
{
status |= ping_echo (*argv++);
ping_reset (ping);
}
return status;
}
struct data_buffer* gen_load_packet(char* cmd,MEM_POOL* mem_pool)
{
char* table_name = NULL;
char* segment_dir = NULL;
char* token = NULL;
uint32_t tblen;
uint32_t dirlen;
uint16_t sid;
if((table_name = strtok(NULL," ")) == NULL)
return NULL;
tblen = strlen(table_name);
if((token = strtok(NULL," ")) == NULL)
return NULL;
sid = atoi(token);
if((segment_dir = strtok(NULL," ")) == NULL)
return NULL;
dirlen = strlen(segment_dir);
struct data_buffer *dbuf = init_data_buffer();
size_t data_len = tblen + dirlen + 10 * sizeof(uint8_t) + MESSAGE_HEAD_LEN + 2*sizeof(uint32_t);
databuf_resize(dbuf, data_len);
//写入数据长度
write_int32(data_len,dbuf);
write_int8(1, dbuf);
write_int8(1, dbuf);
write_int16(MT_CD_EXE_LOAD, dbuf);
write_int32(0, dbuf);
//timeout
write_int32(0, dbuf);
//拼接协议包
write_int32(tblen,dbuf);
write_bytes((uint8_t*)table_name,tblen,dbuf);
write_int16(sid,dbuf);
write_int32(dirlen,dbuf);
write_bytes((uint8_t*)segment_dir,dirlen,dbuf);
return dbuf;
}
int
ping_main (struct Ping_Options *Ping_Opt)
{
int one = 1;
int ret = 0;
if (getuid () == 0)
is_root = true;
/* Parse command line */
parse_opt(Ping_Opt);
ping = ping_init (ICMP_ECHO, getpid ());
if (ping == NULL)
/* ping_init() prints our error message. */
exit (1);
ping_set_sockopt (ping, SO_BROADCAST, (char *) &one, sizeof (one));
/* Reset root privileges */
setuid (getuid ());
if (count != 0)
ping_set_count (ping, count);
if (socket_type != 0)
ping_set_sockopt (ping, socket_type, &one, sizeof (one));
if (options & OPT_INTERVAL)
ping_set_interval (ping, interval);
init_data_buffer (patptr, pattern_len);
ret = ping_echo (Ping_Opt->Host);
Ping_Opt->SuccessCount = ping->ping_num_recv;
Ping_Opt->FailureCount = ping->ping_num_xmit - ping->ping_num_recv;
Ping_Opt->AverageResponseTime = ping->avg_time;
Ping_Opt->MaximumResponseTime = ping->max_time;
Ping_Opt->MinimumResponseTime = ping->min_time;
free (ping);
free (data_buffer);
return ret;
}
struct data_buffer* gen_checkpoint_packet(char* cmd,MEM_POOL* mem_pool)
{
struct data_buffer *dbuf = init_data_buffer();
size_t data_len = MESSAGE_HEAD_LEN + 2*sizeof(uint32_t);
databuf_resize(dbuf, data_len);
//写入数据长度
write_int32(data_len,dbuf);
write_int8(1, dbuf);
write_int8(1, dbuf);
write_int16(MT_CD_EXE_CP, dbuf);
write_int32(0, dbuf);
//timeout
write_int32(0, dbuf);
return dbuf;
}
struct data_buffer* gen_get_load_threshold_packet(char* cmd,MEM_POOL* mem_pool)
{
struct data_buffer *dbuf = init_data_buffer();
size_t data_len = MESSAGE_HEAD_LEN + 2*sizeof(uint32_t);
databuf_resize(dbuf, data_len);
//写入数据长度
write_int32(data_len,dbuf);
write_int8(1, dbuf);
write_int8(1, dbuf);
write_int16(MT_CD_EXE_GET_LOAD_THRESHOLD, dbuf);
write_int32(0, dbuf);
//timeout
write_int32(0, dbuf);
return dbuf;
}
int main()
{
const char filename[] = "cursor.pcf";
int fd = open(filename, O_RDONLY);
struct stat filestat;
fstat(fd, &filestat);
void *fontbuf = mmap(NULL, filestat.st_size, PROT_READ,
MAP_PRIVATE, fd, 0);
handle_pcf(fontbuf);
init_data_buffer();
//output_all_cursors();
output_interesting_cursors();
}
TEST(DATA_BUFFER_TEST, READ_AND_WRITE){
MEM_POOL_PTR pMemPool = mem_pool_init(MB_SIZE);
struct data_buffer* buffer = init_data_buffer();
buffer->data_len = 256;
buffer->data = (uint8*) mem_pool_malloc(pMemPool, 256);
uint8 tmp8;
uint16 tmp16;
uint32 tmp32;
uint64 tmp64;
char* str = (char*) mem_pool_malloc(pMemPool, 100);
char* result = (char*) mem_pool_malloc(pMemPool, 100);
strcpy(str, "hello world!");
write_int8(122, buffer);
write_int16(1111, buffer);
write_int32(324, buffer);
write_int64(2321, buffer);
write_bytes((uint8*)str, strlen(str)+1, buffer);
tmp8 = read_int8(buffer);
ASSERT_EQ(tmp8, 122);
tmp16 = read_int16(buffer);
ASSERT_EQ(tmp16, 1111);
tmp32 = read_int32(buffer);
ASSERT_EQ(tmp32, 324);
tmp64 = read_int64(buffer);
ASSERT_EQ(tmp64, 2321);
read_bytes(buffer, (uint8*)result, strlen(str)+1);
ASSERT_EQ(0, strcmp(str, result));
destroy_data_buffer(buffer);
mem_pool_destroy(pMemPool);
}
struct data_buffer *gen_ldb_control_packet(char *cmd, MEM_POOL *mem_pool)
{
// make cmd to full command
while (strtok(NULL, " "));
struct data_buffer *dbuf = init_data_buffer();
// header
write_int32(0, dbuf);
write_int8(1, dbuf);
write_int8(1, dbuf);
write_int16(MT_CD_EXE_LDB_CONTROL, dbuf);
write_int32(0, dbuf);
//timeout
write_int32(0, dbuf);
write_int32(strlen(cmd), dbuf);
write_bytes((uint8_t *)cmd, strlen(cmd), dbuf);
fill_int32(dbuf->data_len, dbuf, 0);
return dbuf;
}
void csv::flush_field(vector<string>& row) {
row.push_back(string(data_buffer));
init_data_buffer();
}
int main(int argc, char *argv[])
{
int i, iRet = 0;
struct pwcmech * pwcmech;
//
// Signal Handling
//
sigset_t block_no_signals;
sigemptyset(&block_no_signals);
struct sigaction pwc_sig_handler;
struct sigaction standard_sig_handler;
struct sigaction video_io_sig_handler;
pwc_sig_handler.sa_flags = 0;
pwc_sig_handler.sa_handler = &sig_handler;
sigaction(SIGINT, &pwc_sig_handler, &standard_sig_handler);
sigaction(SIGTERM, &pwc_sig_handler, &standard_sig_handler);
video_io_sig_handler.sa_flags = 0;
video_io_sig_handler.sa_handler = &ioctl_callback;
sigaction(SIGIO, &video_io_sig_handler, &standard_sig_handler);
//
// Userspace Driver Interfaces
//
struct devClass * video_dev;
struct images * p_img;
//
// Buffering Initialization
//
printf("Allocating buffers...");
frames = alloc_buffers();
if ( frames == NULL )
{
printf("failed?!\n");
goto finish;
}
init_data_buffer(frames);
printf("done!\n");
//
// Device Initialization
//
printf("Create camera device...");
pwcmech = pwc_devmech_start();
if ( pwcmech_register_driver(pwcmech) )
{
printf("failed?!\n");
goto release_buffers;
}
printf("done!\n");
printf("Initialize camera device...");
if ( pwcmech_register_handler(pwcmech) )
{
perror("Failed opening camera device");
printf("failed?!\n");
goto stop_usb;
}
printf("done!\n");
printf("Set camera's video mode...");
//if_claim should work seamslessly somehow
iRet = usb_if_claim(pwcmech->com, pwcmech->com->standard_descriptors.highspeed.cameraStream.cameraStreamConf);
if ( iRet )
{
perror("Failed setting camera's video mode");
printf("failed?!\n");
goto close_camera;
}
iRet = setVideoMode(pwcmech, 9); //still old way, pre-setting instead of from V4L
if ( iRet )
{
perror("Failed setting camera's video mode");
printf("failed?!\n");
goto close_camera;
}
set_ctrl0_timeout(pwcmech->com, 1000);
setLeds(pwcmech, 0,0); //don't bother with the light
iRet = sendVideoCommand(pwcmech, video_mode_string, VIDEO_MODE_STRING_LEN);
if ( iRet )
{
perror("Failed setting camera's video mode");
printf("failed?!\n");
goto close_camera;
}
printf("done!\n");
//
// Decompression
//
printf("Initializing decompression system...");
p_img = alloc_images();
if ( p_img == NULL )
{
printf("failed?!\n");
goto close_camera;
}
if ( ( iRet = init_images(p_img) ) )
{
printf("failed?!\n");
goto free_p_img;
}
printf("done!\n");
#ifndef NO_IMG
//
// Open video pipe
//
printf("Opening the video pipe (vl4 device emulation)...");
video_dev = alloc_devClass();
if ( video_dev == NULL )
{
printf("failed?!\n");
goto free_p_img;
}
p_img->img_buf = init_devClass(video_dev, argv[1], p_img);
if ( p_img->img_buf == NULL )
{
perror("Initializing device class failed");
printf("failed?!\n");
printf("Did you input the device path, \"/dev/video0\"?\"\n\n\n");
goto free_video_dev;
}
printf("done!\n");
#endif
//
// ISO transfers
//
printf("Create USB isochronous transfers...");
for (i = 0; i < ISO_BUFFERS_NR; i++)
{
iRet = assignVideoBuffer(pwcmech, frames->iso_buffer[i], ISO_BUFFER_SIZE);
if (iRet)
{
perror("Failed creating image transfer");
printf("failed?!\n");
goto unregister_buffers;
}
}
printf("done!\n");
//
// Threads
//
printf("Set-up threads...");
int active_threads = 0;
pthread_t threads[NUM_THREADS];
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
struct acqArg * acq_arg;
acq_arg = malloc(sizeof(struct acqArg));
if ( acq_arg == NULL )
{
printf("failed?!\n");
goto close_threads;
}
acq_arg->abort = &thread_abort;
acq_arg->pwcmech = pwcmech;
struct imgArg * img_arg;
img_arg = malloc(sizeof(struct imgArg));
if ( img_arg == NULL )
{
printf("failed?!\n");
goto close_threads;
}
img_arg->frames = frames;
img_arg->p_img = p_img;
img_arg->video_pipe = video_dev;
img_arg->capture = 0;
img_arg->abort = &thread_abort;
printf("done!\n");
//
// MAIN
//
printf("Registering callback function for Isochronous transfer...");
setPower(pwcmech, 0); //enable camera (our state machine discovered that this was missing)
registerVideoCallback(pwcmech, acquire_frame, pwcmech);
if ( acknowledgeVideoCallback(pwcmech) )
goto close_threads;
printf("done!\n");
#ifndef NO_COM
printf("Creating the data acquisition thread...");
if ( ( iRet = pthread_create(&threads[active_threads], &attr, process_usb, (void *)acq_arg) ) )
{
printf("failed?!\n");
goto stop_camera;
}
active_threads++;
printf("done!\n");
#endif
#ifndef NO_IMG
printf("Creating the image fill thread...");
if ( ( iRet = pthread_create(&threads[active_threads], &attr, fillImageData, (void *)img_arg) ) )
{
printf("failed?!\n");
goto stop_camera;
}
active_threads++;
printf("done!\n");
#endif
while (!op_abort)
{
// sigsuspend(&block_no_signals);
if ( ioctl_call )
{
devClass_ioctl(video_dev, &img_arg->capture);
ioctl_call = 0;
}
}
//
// ~MAIN
//
stop_camera:
printf("Releasing video callback...");
releaseVideoCallback(pwcmech);
printf("done!\n");
printf("Unregistering buffers...");
unassignVideoBuffers(pwcmech);
printf("done!\n");
close_threads:
printf("Closing all threads...");
thread_abort = 1;
for ( i = 0; i < active_threads; i++)
pthread_join(threads[i], NULL);
free(acq_arg);
free(img_arg);
pthread_attr_destroy(&attr);
printf("done!\n");
unregister_buffers:
printf("Unregistering buffers if not done before...");
unassignVideoBuffers(pwcmech);
printf("done!\n");
free_video_dev:
#ifndef NO_IMG
printf("Closing video pipe...");
close_devClass(video_dev);
free_devClass(video_dev);
printf("done!\n");
#endif
free_p_img:
printf("Releasing decompression system...");
free_images(p_img);
printf("done!\n");
usb_release_interface(pwcmech->com, pwcmech->com->standard_descriptors.highspeed.cameraStream.cameraStreamConf);
close_camera:
printf("Close camera device...");
pwcmech_deregister_handler(pwcmech);
printf("done!\n");
stop_usb:
printf("Stopping USB interface...");
pwcmech_deregister_driver(pwcmech);
printf("done!\n");
release_buffers:
pwc_devmech_stop(pwcmech);
//release buffers, they are linked to the camera device
//so only release them after releasing the camera
printf("Releasing buffers...");
free_buffers(frames);
printf("done!\n");
finish:
return 0;
}
