/*START_OF_MAIN*/
int main()
{   
    int i=0;
    combine_type person_info;
    read_and_write("person_info.txt","person_info.bin");
    read_binary("person_info.bin",person_info);
    
    
    return 0;
    /*END_OF_MAIN*/
}
예제 #2
0
파일: spit.cpp 프로젝트: sukumarb/firebird
static int gen_multy_bakup_files(b_fil* file_list, FILE_DESC input_file_desc, SLONG file_num)
{
/********************************************************************
**
**	g e n _ m u l t y _ b a c k u p _ f i l e s
**
*********************************************************************
**
**	Functional description:
**
**		processing input data from stdin and splits the data into
**		multiple back-up files.
**
**		allocates an 16K bytes I/O buffer
**		intilializes header record common fields
**		do forever
**			walk through the backup file chain
**			intilializes header record unique fields
**			open backup file
**			writes out header record to backup file
**			points to the next backup file in the chain
**			calculates the actual file size ( minus header record length )
**			if the actual file size less than 16K bytes
**				set I/O size to actual file size
**			otherwise
**				set I/O size to 16K byte long
**			when it is the last backup file
**				reads data from standard input as much as indicated by I/O size
**					and writes it out to the last backup file until no EOF.
**				issues error message when disk space full condition is detected
**			otherwise reads and writes to backup files util EOF
**				if disk full cobdition is detected
**					flush the remaining data in the I/O buffer to subsequence
**							backup files
**				go back to normal read and write process util EOF
**
*********************************************************************
*/

	SLONG byte_write, ret_cd;
	TEXT header_str[header_rec_len], num_arr[5];
	header_rec hdr_rec;

	// CVC: there's a can of worms here. First, this function assumes it can free
	// the io_buffer's allocated memory without keeping a second copy of that pointer.
	// However, io_buffer can't be declared UCHAR* const because its address is
	// passed to final_read_and_write() and read_and_write() and both functions
	// thus suggest, by taking a UCHAR** that they can change the pointer's address;
	// but in practice they never affect it, so fixing those functions to take simply
	// UCHAR* would allow the correct declaration for io_buffer to succeed.
	//UCHAR* const io_buffer = (UCHAR *) malloc(IO_BUFFER_SIZE);
	UCHAR* io_buffer = (UCHAR *) malloc(IO_BUFFER_SIZE);

	if (!io_buffer)
	{
		fprintf(stderr, "I/O buffer allocation failed\n");
		return FB_FAILURE;
	}

	size_t pos;
	for (pos = 0; pos < header_rec_len; pos++)
		header_str[pos] = BLANK;

	pos = 0;
	ret_cd = set_hdr_str(header_str, header_rec_name, pos, sizeof(hdr_rec.name));
	size_t indx;
	for (indx = 0; indx < sizeof(hdr_rec.name); indx++)
		hdr_rec.name[indx] = BLANK;

	pos = pos + sizeof(hdr_rec.name);
	time_t clock = time(0);  // was SLONG
	ret_cd = set_hdr_str(header_str, ctime(&clock), pos, sizeof(hdr_rec.date_time));
	for (indx = 0; indx < sizeof(hdr_rec.date_time); indx++)
		hdr_rec.date_time[indx] = BLANK;

	pos = pos + sizeof(hdr_rec.date_time);
	ret_cd = set_hdr_str(header_str, ", file No. ", pos, sizeof(hdr_rec.text1));
	for (indx = 0; indx < sizeof(hdr_rec.text1); indx++)
		hdr_rec.text1[indx] = BLANK;

	for (indx = 0; indx < sizeof(hdr_rec.num); indx++)
		hdr_rec.num[indx] = BLANK;

	pos = pos + sizeof(hdr_rec.text1) + sizeof(hdr_rec.num);
	ret_cd = set_hdr_str(header_str, " of ", pos, sizeof(hdr_rec.text2));
	for (indx = 0; indx < sizeof(hdr_rec.text2); indx++)
		hdr_rec.text2[indx] = BLANK;

	ret_cd = conv_ntoc(file_num, num_arr);
	if (ret_cd == FB_FAILURE)
	{
		free(io_buffer);
		fprintf(stderr, "gsplit could not convert numeric data to character data\n");
		return FB_FAILURE;
	}

	num_arr[sizeof(num_arr) - 1] = TERMINAL;
	pos = pos + sizeof(hdr_rec.text2);
	ret_cd = set_hdr_str(header_str, num_arr, pos, sizeof(hdr_rec.total));
	for (indx = 0; indx < sizeof(hdr_rec.total); indx++)
		hdr_rec.total[indx] = BLANK;

	pos = pos + sizeof(hdr_rec.total);
	ret_cd = set_hdr_str(header_str, ", ", pos, sizeof(hdr_rec.text3));
	for (indx = 0; indx < sizeof(hdr_rec.text3); indx++)
		hdr_rec.text3[indx] = BLANK;

	for (indx = 0; indx < sizeof(hdr_rec.fl_name); indx++)
		hdr_rec.fl_name[indx] = BLANK;

	FILE_DESC output_fl_desc = 0;
	bool end_of_input = false, flush_done = false;
	const TEXT* file_name = NULL;
	SLONG io_size = 0;
	b_fil* fl_ptr = file_list;

	SINT64 byte_read = 0;
	SINT64 file_size = 0;

	while (true)
	{
		if (fl_ptr != NULL)
		{
			byte_read = 0;
			byte_write = 0;
			if (!fl_ptr->b_fil_next && (fl_ptr->b_fil_size == 0))
			{
				fl_ptr->b_fil_size = MIN_FILE_SIZE;
			}

			file_size = fl_ptr->b_fil_size - header_rec_len;
			file_name = fl_ptr->b_fil_name;

			output_fl_desc = open_platf(file_name, 1);
			if (output_fl_desc == INVALID_HANDLE_VALUE)
			{
				free(io_buffer);
				fprintf(stderr, "can not open back up file %s\n", file_name);
				return FB_FAILURE;
			}

			ret_cd = write_header(fl_ptr, hdr_rec, output_fl_desc, header_str);
			if (ret_cd == FB_FAILURE)
			{
				free(io_buffer);
				fprintf(stderr, "could not write header record to file %s\n", file_name);
				return FB_FAILURE;
			}

			fl_ptr = fl_ptr->b_fil_next;
		}

		if (file_size < IO_BUFFER_SIZE)
			io_size = (SLONG) file_size;
		else
			io_size = IO_BUFFER_SIZE;

		if (!fl_ptr)
		{
			while (!end_of_input)
			{
				ret_cd = final_read_and_write(input_file_desc, output_fl_desc,
											  file_name, io_size, &io_buffer, &end_of_input);
				if (ret_cd == FB_FAILURE)
				{
					free(io_buffer);
					return FB_FAILURE;
				}

				if (end_of_input)
				{
					free(io_buffer);
					return FB_SUCCESS;
				}
			}
		}
		else
		{
			while ((file_size > byte_read) && (fl_ptr != NULL))
			{
				ret_cd = read_and_write(input_file_desc, output_fl_desc,
										/*file_name,*/ io_size, file_size,
										&io_buffer, &end_of_input,
										&byte_read, &byte_write);
				switch (ret_cd)
				{
				case FB_FAILURE:
					free(io_buffer);
					return FB_FAILURE;

				case FILE_IS_FULL:
					{
						byte_read = 0;	// reset byte read count, prepare for next read

						const UCHAR* remaining_io = io_buffer + byte_write;
						SLONG remaining_io_len = IO_BUFFER_SIZE - byte_write;
						while (!flush_done && (fl_ptr != NULL))
						{
							if (!fl_ptr->b_fil_next && fl_ptr->b_fil_size == 0)
								fl_ptr->b_fil_size = MIN_FILE_SIZE;

							file_size = fl_ptr->b_fil_size - header_rec_len;
							file_name = fl_ptr->b_fil_name;

							output_fl_desc = open_platf(file_name, 1);
							if (output_fl_desc == INVALID_HANDLE_VALUE)
							{
								free(io_buffer);
								fprintf(stderr, "can not open back up file %s\n", file_name);
								return FB_FAILURE;
							}
							ret_cd = write_header(fl_ptr, hdr_rec, output_fl_desc, header_str);
							if (ret_cd == FB_FAILURE)
							{
								free(io_buffer);
								fprintf(stderr, "fail to write header rec to file %s\n", file_name);
								return FB_FAILURE;
							}

							fl_ptr = fl_ptr->b_fil_next;
							if (!fl_ptr)
							{
								ret_cd = final_flush_io_buff(remaining_io,
															 remaining_io_len,
															 output_fl_desc);
								if (ret_cd == FB_FAILURE)
								{
									fprintf(stderr, "gsplit could not do backup due");
									fprintf(stderr, " to lack of space or I/O problem\n");
									free(io_buffer);
									return FB_FAILURE;
								}
							}
							else
							{
								// got a lot of backup files

								ret_cd = flush_io_buff(remaining_io,
													   remaining_io_len,
													   output_fl_desc,
													   file_size,
													   &byte_write,
													   &flush_done);
								if (ret_cd == FB_FAILURE)
								{
									fprintf(stderr, "gsplit could not do backup due");
									fprintf(stderr, " I/O problem\n");
									free(io_buffer);
									return FB_FAILURE;
								}
								if (flush_done)
								{
									file_size = file_size - byte_write;
									byte_write = 0;
								}
								else
								{
									remaining_io = remaining_io + byte_write;
									remaining_io_len = remaining_io_len - byte_write;
								}
							}
						}		// end of while loop
						break;
					} // case FILE_IS_FULL

				default:
					break;
				}

				if (end_of_input)
				{
					free(io_buffer);
					return FB_SUCCESS;
				}
			}
		}
	}	// end of while ( true )
}
예제 #3
0
static gpointer
worker_thread(
    gpointer data)
{
    XferElement *elt = XFER_ELEMENT(data);
    XferElementGlue *self = XFER_ELEMENT_GLUE(data);

    switch (mech_pair(elt->input_mech, elt->output_mech)) {
    case mech_pair(XFER_MECH_READFD, XFER_MECH_WRITEFD):
	read_and_write(self);
	break;

    case mech_pair(XFER_MECH_READFD, XFER_MECH_PUSH_BUFFER):
    case mech_pair(XFER_MECH_WRITEFD, XFER_MECH_PUSH_BUFFER):
	read_and_push(self);
	break;

    case mech_pair(XFER_MECH_PULL_BUFFER, XFER_MECH_READFD):
    case mech_pair(XFER_MECH_PULL_BUFFER, XFER_MECH_WRITEFD):
	pull_and_write(self);
	break;

    case mech_pair(XFER_MECH_PULL_BUFFER, XFER_MECH_PUSH_BUFFER):
	pull_and_push(self);
	break;

    case mech_pair(XFER_MECH_READFD, XFER_MECH_DIRECTTCP_LISTEN):
    case mech_pair(XFER_MECH_WRITEFD, XFER_MECH_DIRECTTCP_LISTEN):
	if ((self->output_data_socket = do_directtcp_connect(self,
				    elt->downstream->input_listen_addrs)) == -1)
	    break;
	self->write_fdp = &self->output_data_socket;
	read_and_write(self);
	break;

    case mech_pair(XFER_MECH_PULL_BUFFER, XFER_MECH_DIRECTTCP_LISTEN):
	if ((self->output_data_socket = do_directtcp_connect(self,
				    elt->downstream->input_listen_addrs)) == -1)
	    break;
	self->write_fdp = &self->output_data_socket;
	pull_and_write(self);
	break;

    case mech_pair(XFER_MECH_DIRECTTCP_LISTEN, XFER_MECH_READFD):
    case mech_pair(XFER_MECH_DIRECTTCP_LISTEN, XFER_MECH_WRITEFD):
	if ((self->input_data_socket = do_directtcp_accept(self, &self->input_listen_socket)) == -1)
	    break;
	self->read_fdp = &self->input_data_socket;
	read_and_write(self);
	break;

    case mech_pair(XFER_MECH_DIRECTTCP_LISTEN, XFER_MECH_PUSH_BUFFER):
	if ((self->input_data_socket = do_directtcp_accept(self,
					    &self->input_listen_socket)) == -1)
	    break;
	self->read_fdp = &self->input_data_socket;
	read_and_push(self);
	break;

    case mech_pair(XFER_MECH_DIRECTTCP_CONNECT, XFER_MECH_PULL_BUFFER):
    case mech_pair(XFER_MECH_DIRECTTCP_LISTEN, XFER_MECH_PULL_BUFFER):
    case mech_pair(XFER_MECH_READFD, XFER_MECH_PULL_BUFFER):
    case mech_pair(XFER_MECH_WRITEFD, XFER_MECH_READFD):
    case mech_pair(XFER_MECH_WRITEFD, XFER_MECH_PULL_BUFFER):
    case mech_pair(XFER_MECH_PUSH_BUFFER, XFER_MECH_READFD):
    case mech_pair(XFER_MECH_PUSH_BUFFER, XFER_MECH_WRITEFD):
    case mech_pair(XFER_MECH_PUSH_BUFFER, XFER_MECH_PULL_BUFFER):
    case mech_pair(XFER_MECH_PUSH_BUFFER, XFER_MECH_DIRECTTCP_LISTEN):
    case mech_pair(XFER_MECH_PUSH_BUFFER, XFER_MECH_DIRECTTCP_CONNECT):
    default:
	g_assert_not_reached();
	break;

    case mech_pair(XFER_MECH_WRITEFD, XFER_MECH_DIRECTTCP_CONNECT):
    case mech_pair(XFER_MECH_READFD, XFER_MECH_DIRECTTCP_CONNECT):
	if ((self->output_data_socket = do_directtcp_accept(self,
					    &self->output_listen_socket)) == -1)
	    break;
	self->write_fdp = &self->output_data_socket;
	read_and_write(self);
	break;

    case mech_pair(XFER_MECH_DIRECTTCP_CONNECT, XFER_MECH_WRITEFD):
    case mech_pair(XFER_MECH_DIRECTTCP_CONNECT, XFER_MECH_READFD):
	if ((self->input_data_socket = do_directtcp_connect(self,
				    elt->upstream->output_listen_addrs)) == -1)
	    break;
	self->read_fdp = &self->input_data_socket;
	read_and_write(self);
	break;

    case mech_pair(XFER_MECH_DIRECTTCP_CONNECT, XFER_MECH_PUSH_BUFFER):
	if ((self->input_data_socket = do_directtcp_connect(self,
				    elt->upstream->output_listen_addrs)) == -1)
	    break;
	self->read_fdp = &self->input_data_socket;
	read_and_push(self);
	break;

    case mech_pair(XFER_MECH_PULL_BUFFER, XFER_MECH_DIRECTTCP_CONNECT):
	if ((self->output_data_socket = do_directtcp_accept(self,
					    &self->output_listen_socket)) == -1)
	    break;
	self->write_fdp = &self->output_data_socket;
	pull_and_write(self);
	break;

    case mech_pair(XFER_MECH_DIRECTTCP_LISTEN, XFER_MECH_DIRECTTCP_CONNECT):
	/* TODO: use async accept's here to avoid order dependency */
	if ((self->output_data_socket = do_directtcp_accept(self,
					    &self->output_listen_socket)) == -1)
	    break;
	self->write_fdp = &self->output_data_socket;
	if ((self->input_data_socket = do_directtcp_accept(self,
					    &self->input_listen_socket)) == -1)
	    break;
	self->read_fdp = &self->input_data_socket;
	read_and_write(self);
	break;

    case mech_pair(XFER_MECH_DIRECTTCP_CONNECT, XFER_MECH_DIRECTTCP_LISTEN):
	/* TODO: use async connects and select() to avoid order dependency here */
	if ((self->input_data_socket = do_directtcp_connect(self,
				    elt->upstream->output_listen_addrs)) == -1)
	    break;
	self->read_fdp = &self->input_data_socket;
	if ((self->output_data_socket = do_directtcp_connect(self,
				    elt->downstream->input_listen_addrs)) == -1)
	    break;
	self->write_fdp = &self->output_data_socket;
	read_and_write(self);
	break;
    }

    send_xfer_done(self);

    return NULL;
}
예제 #4
0
파일: list.c 프로젝트: Sherlock221B/burp
static int write_wrapper(struct asfd *asfd, struct iobuf *wbuf)
{
	while(asfd->append_all_to_write_buffer(asfd, wbuf))
		if(read_and_write(asfd)) return -1;
	return 0;
}
예제 #5
0
파일: list.c 프로젝트: Sherlock221B/burp
static int flush_asio(struct asfd *asfd)
{
	while(asfd->writebuflen>0)
		if(read_and_write(asfd)) return -1;
	return 0;
}
예제 #6
0
int
main(int argc, char **argv)
{
	static const struct option longopts[] = {
		{ "help", 0, 0, 'h' },
		{ "verbose", 0, 0, 'v' },
		{ "listen", 0, 0, 'l' },
		{ "connect", 0, 0, 'c' },
		{ "node", 1, 0, 'n' },
		{ "host", 1, 0, 'n' },
		{ "service", 1, 0, 's' },
		{ "family", 1, 0, 'f' },
		{ "socktype", 1, 0, 't' },
		{ "ping", 0, 0, 'I' },
		{ "protocol", 1, 0, 'p' },
		{ "backends", 1, 0, 'b' },
		{ "srv", 0, 0, 'S' },
		{ "address", 1, 0, 'a' },
		{ "port", 1, 0, 'P' },
		{ "class", 1, 0, 'C' },
		{ "type", 1, 0, 'T' },
		{ NULL, 0, 0, 0 }
	};
	static const char *opts = "hvcn::s:f:t:p:b:Sa:P:";
	int opt, idx = 0;
	bool do_connect = false;
	bool do_listen = false;
	bool ping = false;
	char *nodename = NULL, *servname = NULL;
	char *address_str = NULL, *port_str = NULL;
	int cls = ns_c_in, type = 0;
	netresolve_t context;
	netresolve_query_t query;

	netresolve_set_log_level(NETRESOLVE_LOG_LEVEL_ERROR);

	context = netresolve_context_new();
	if (!context) {
		error("netresolve: %s\n", strerror(errno));
		return EXIT_FAILURE;
	}

	while ((opt = getopt_long(count_argv(argv), argv, opts, longopts, &idx)) != -1) {
		switch (opt) {
		case 'h':
			usage();
		case 'v':
			netresolve_set_log_level(NETRESOLVE_LOG_LEVEL_DEBUG);
			break;
		case 'l':
			do_listen = true;
			break;
		case 'c':
			do_connect = true;
			break;
		case 'I':
			ping = true;
			break;
		case 'n':
			nodename = optarg;
			break;
		case 's':
			servname = optarg;
			break;
		case 'f':
			netresolve_context_set_options(context,
					NETRESOLVE_OPTION_FAMILY, netresolve_family_from_string(optarg),
					NETRESOLVE_OPTION_DONE);
			break;
		case 't':
			netresolve_context_set_options(context,
					NETRESOLVE_OPTION_SOCKTYPE, netresolve_socktype_from_string(optarg),
					NETRESOLVE_OPTION_DONE);
			break;
		case 'p':
			netresolve_context_set_options(context,
					NETRESOLVE_OPTION_PROTOCOL, netresolve_protocol_from_string(optarg),
					NETRESOLVE_OPTION_DONE);
			break;
		case 'b':
			netresolve_set_backend_string(context, optarg);
			break;
		case 'S':
			netresolve_context_set_options(context,
					NETRESOLVE_OPTION_DNS_SRV_LOOKUP, (int) true,
					NETRESOLVE_OPTION_DONE);
			break;
		case 'a':
			address_str = optarg;
			break;
		case 'P':
			port_str = optarg;
			break;
		case 'C':
#ifdef USE_LDNS
			cls = ldns_get_rr_class_by_name(optarg);
#else
			cls = strtoll(optarg, NULL, 10);
#endif
			break;
		case 'T':
#ifdef USE_LDNS
			type = ldns_get_rr_type_by_name(optarg);
#else
			type = strtoll(optarg, NULL, 10);
#endif
			break;
		default:
			exit(EXIT_FAILURE);
		}
	}

	if (argv[optind])
		usage();

	if (do_listen || do_connect) {
		netresolve_query_t query;
		int sock = -1;
		struct pollfd fds[2];

		/* Linux: I found an interesting inconsistency where zero socktype
		 * is supported by the kernel but not when combined with
		 * `SOCK_NONBLOCK` which is internally used by netresolve
		 * socket API implementation.
		 */
		if (!context->request.socktype && !context->request.protocol) {
			context->request.socktype = SOCK_STREAM;
			context->request.protocol = IPPROTO_TCP;
		}

		if (do_listen) {
			if (!(query = netresolve_listen(context, nodename, servname, 0, 0, 0))) {
				error("netresolve: Cannot create listening socket: %s", strerror(errno));
				return EXIT_FAILURE;
			}

			netresolve_accept(query, on_accept, &sock);
		} else {
			query = netresolve_connect(context, nodename, servname, 0, 0, 0, on_socket, &sock);

			while (sock == -1) {
				error("netresolve: Socket connection failed: %s", strerror(errno));

				if (errno == ENETUNREACH) {
					netresolve_connect_next(query);
					continue;
				}

				return EXIT_FAILURE;
			}

			netresolve_connect_free(query);
		}

		debug("Connected.");

		fds[0].fd = 0;
		fds[0].events = POLLIN;
		fds[1].fd = sock;
		fds[1].events = POLLIN;

		while (true) {
			if (poll(fds, 2, -1) == -1) {
				fprintf(stderr, "poll: %s\n", strerror(errno));
				break;
			}

			if (fds[0].revents & (POLLIN | POLLHUP))
				read_and_write(0, sock, sock);
			if (fds[1].revents & POLLIN)
				read_and_write(sock, 1, sock);
		}

		return EXIT_SUCCESS;
	} else if (type)
		query = netresolve_query_dns(context, nodename, cls, type, NULL, NULL);
	else if (address_str || port_str) {
		Address address;
		int family, ifindex;

		if (!netresolve_backend_parse_address(address_str, &address, &family, &ifindex))
			return EXIT_FAILURE;
		query = netresolve_query_reverse(context, family, &address, ifindex, -1, port_str ? strtol(port_str, NULL, 10) : 0, NULL, NULL);
	} else
		query = netresolve_query_forward(context, nodename, servname, NULL, NULL);

	if (!query) {
		fprintf(stderr, "netresolve: %s\n", strerror(errno));
		return EXIT_FAILURE;
	}

	debug("%s", netresolve_get_request_string(query));

	if (ping) {
		for (int i = 0; i < netresolve_query_get_count(query); i++)
			if (run_ping(query, i))
				goto out;
		error("netresolve: ping failed");
		goto out;
	}

	const char *response_string = netresolve_get_response_string(query);
	char *dns_string = get_dns_string(query);

	if (response_string)
		printf("%s", response_string);
	if (dns_string) {
		printf("%s", dns_string);
		free(dns_string);
	}

out:
	netresolve_context_free(context);
	return EXIT_SUCCESS;
}
예제 #7
0
int main(int argc, char* argv[]) {

  int which = 0;

  data_t *heap_data = (data_t *)malloc(sizeof(data_t));

  if (argc >= 2) {
    which = atoi(argv[1]);
  }
  init(&global_data);     
  init(heap_data);     

  switch(which) {
    case 0:
      cilk_spawn increment_i(&global_data); // write, read race
      mult_double(&global_data);
      cilk_sync;
      assert(__cilksan_error_count() == 3);
      break;

    case 1:
      cilk_spawn mult_double(&global_data);
      increment_i(&global_data); // write, read race
      cilk_sync;
      assert(__cilksan_error_count() == 3);
      break;

    case 2:
      cilk_spawn mult_double(&global_data);
      update_str(&global_data, 3, 8); // read, write race
      cilk_sync;
      assert(__cilksan_error_count() == 2);
      break;

    case 3:
      cilk_spawn increment_i(&global_data); // write, read race
      read_double(&global_data);
      cilk_sync;
      assert(__cilksan_error_count() == 1);
      break;

    case 4:
      cilk_spawn read_double(&global_data);
      increment_i(&global_data); // read, write race
      cilk_sync;
      assert(__cilksan_error_count() == 1);
      break;

    case 5:
      cilk_spawn read_double(&global_data);
      update_str(&global_data, 3, 8); // read, write race
      cilk_sync;
      assert(__cilksan_error_count() == 1);
      break;

    case 6:
      cilk_spawn read_str(&global_data, 2, 4);
      update_str(&global_data, 3, 8); // read, write race
      cilk_sync;
      assert(__cilksan_error_count() == 1);
      break;

    case 7:
      cilk_spawn increment_i(heap_data); // write, read race
      mult_double(heap_data);
      cilk_sync;
      assert(__cilksan_error_count() == 3);
      break;

    case 8:
      cilk_spawn mult_double(heap_data);
      increment_i(heap_data); // write, read race
      cilk_sync;
      assert(__cilksan_error_count() == 3);
      break;

    case 9:
      cilk_spawn mult_double(heap_data);
      update_str(heap_data, 3, 8); // write, write race
      cilk_sync;
      assert(__cilksan_error_count() == 2);
      break;

    case 10:
      cilk_spawn increment_i(heap_data); // write, read race
      read_double(heap_data);
      cilk_sync;
      assert(__cilksan_error_count() == 1);
      break;

    case 11:
      cilk_spawn read_double(heap_data);
      increment_i(heap_data); // read, write race
      cilk_sync;
      // to be sure that compiler doesn't optimize it away.
      global_int = heap_data->i; 
      assert(__cilksan_error_count() == 1);
      break;

    case 12:
      cilk_spawn read_double(heap_data);
      update_str(heap_data, 3, 8); // read, write race
      cilk_sync;
      assert(__cilksan_error_count() == 1);
      break;

    case 13:
      cilk_spawn update_str(heap_data, 8, 11);
      read_str(heap_data, 10, 12); // write, read race
      cilk_sync;
      assert(__cilksan_error_count() == 1);
      break;

    case 14:
      cilk_spawn update_str(&global_data, 8, 12); // no race
      mult_double(&global_data);
      cilk_sync;
      assert(__cilksan_error_count() == 0);
      break;

    case 15:
      cilk_spawn update_str(&global_data, 4, 12); // no race
      read_i(&global_data);
      cilk_sync;
      assert(__cilksan_error_count() == 0);
      break;

    case 16:
      cilk_spawn update_str(heap_data, 8, 12); // no race
      mult_double(heap_data);
      cilk_sync;
      assert(__cilksan_error_count() == 0);
      break;

    case 17:
      cilk_spawn update_str(heap_data, 4, 12); // no race
      read_i(heap_data);
      cilk_sync;
      assert(__cilksan_error_count() == 0);
      break;

    case 18:
      cilk_spawn update_str(heap_data, 3, 5); // no race 
      update_str(heap_data, 5, 8);
      cilk_sync;
      assert(__cilksan_error_count() == 0);
      break;

    case 19:
      read_and_write(&global_data); // read write race, but just 1
      read_and_write(heap_data);
      cilk_sync;
      assert(__cilksan_error_count() == 1);
      break;
  }
  cilk_sync;
  free(heap_data);

  return 0;
}