Exemple #1
0
void request(const int rtype) { /* room_users_list is not handled */
	if (is_logged() && rtype >= USERS_LIST && rtype <= ROOM_USERS_LIST ) {
		if (allocate_mem(REQUEST, &request_data)) {
			request_data->type = REQUEST;
			request_data->request_type = rtype;
			strcpy(request_data->user_name, username);
			if (send_message(request_data->type, request_data) != FAIL)  {
				int mtype = (rtype == USERS_LIST) ? USERS : (rtype == ROOMS_LIST) ? ROOMS : ROOM_USERS;
				if (allocate_mem(mtype, &request_response_data)) {
					if (wait_until_received(mtype) != FAIL) {
						display_request_result();	
					}
					else {
						writestr("Request wasn't proceeded.");
					}
					free_mem(request_response_data);
				}
				else {
					writestr("Couldn't allocate data structure.");
				}
			}
			free_mem(request_data);
		}
		else {
			writestr("Couldn't allocate request_data structure.");
		}
	}
	else {
		writestr("To perform this, you have to be logged in.");
	}
}
Exemple #2
0
void join(char * str) {
	if (!is_inroom() && is_logged()) {
		if (allocate_mem(ROOM, &room_data)) {
			room_data->type = ROOM;
			room_data->operation_type = ENTER_ROOM;
			strcpy(room_data->user_name, username);
			strcpy(room_data->room_name, str);
			if (send_message(room_data->type, room_data) != FAIL && wait_until_received(RESPONSE) != FAIL) {
				if (response_data.response_type == ENTERED_ROOM_SUCCESS) {
					char buf[50];
					inroom = 1;
					strcpy(roomname, room_data->room_name);
					sprintf(buf, "%s: %s", "You've successfully entered room", roomname);
					writestr(buf);
				}
				else {
					writestr("Couldn't enter room.");
				}
			}
			else {
				writestr("Server didn't answer.");	
			}
			free_mem(room_data);
		}
	}
	else if (is_inroom() && is_logged()) {
		if (strcmp(str, roomname)) { /* User didn't choose the same room to log in again */
			if (allocate_mem(ROOM, &room_data)) {
				room_data->type = ROOM;
				room_data->operation_type = CHANGE_ROOM;
				strcpy(room_data->user_name, username);
		   		strcpy(room_data->room_name, str);
				if (send_message(room_data->type, room_data) != FAIL && wait_until_received(RESPONSE) != FAIL) {
           			if (response_data.response_type == CHANGE_ROOM_SUCCESS) {
						char buf[50];
						strcpy(roomname, room_data->room_name);
						sprintf(buf, "%s: %s", "You've successfully changed room for", roomname);
						writestr(buf);
            		}
            		else {
                		writestr("Couldn't change room.");
            		}
        		}
				else {
					writestr("Server didn't answer");
				}
				free_mem(room_data);
			}
			else {
				writestr("Couldn't allocate room_data structure.");
			}
		}
		else {
			writestr("No use in entering the same room again.");
		}
	}
	else {
		writestr("To perform it, you have to be logged in.");
	}
}
struct tp *
tp_create(int max_jobs) {
    struct tp *pool = allocate_mem(sizeof(*pool));

    pool->jobs = allocate_mem(sizeof(struct tp_entry)*max_jobs);
    pool->capacity = max_jobs;
    pool->size = 0;
    pthread_mutex_init(&pool->mutex, 0);

    return pool;
}
Exemple #4
0
/*创建新的进程,主要是获取内存的申请数量*/
int new_process(){
    struct allocated_block *ab;
    int size;    int ret;
    ab=(struct allocated_block *)malloc(sizeof(struct allocated_block));
    if(!ab) exit(-5);
    ab->next = NULL;
    pid++;
    sprintf(ab->process_name, "PROCESS-%02d", pid);
    ab->pid = pid;    
    printf("Memory for %s:", ab->process_name);
    scanf("%d", &size);
    if(size>0)  ab->size=size;
      ret = allocate_mem(ab);  /* 从空闲区分配内存,ret==1表示分配ok*/
    /*如果此时allocated_block_head尚未赋值,则赋值*/
    if((ret==1) &&(allocated_block_head == NULL)){ 
      allocated_block_head=ab;
      return 1;        
    }
   /*分配成功,将该已分配块的描述插入已分配链表*/
    else if (ret==1) {
      ab->next=allocated_block_head;
      allocated_block_head=ab;
      return 2;        
    }else if(ret==-1){ /*分配不成功*/
      printf("Allocation fail\n");//
      free(ab);
      return -1;       
    }
    return 3;
}
Exemple #5
0
void leave() {
	if (is_inroom()) {
		if (allocate_mem(ROOM, &room_data)) {
			room_data->type = ROOM;
			room_data->operation_type = LEAVE_ROOM;
			strcpy(room_data->user_name, username);
			strcpy(room_data->room_name, roomname);
			if (send_message(room_data->type, room_data) != FAIL && wait_until_received(RESPONSE) != FAIL) {
				inroom = 0;
           		if (response_data.response_type == LEAVE_ROOM_SUCCESS) {
           			writestr("Successfully left room");
				}
				else {
					writestr("Some error occurred.");
				}
			}
			free_mem(room_data);
		}
		else {
			writestr("Couldn't allocate room_data structure.");
		}
	}
	else {
		writestr("To perform it, you have to be in room.");
	}
}
char *
read_stdin(int *stdin_size) {
    int input_size;
	char *temp = NULL; 

#ifdef ARRAYFILE
    input_size = fasta_output_len;
#else
    struct stat stat;
    fstat(0, &stat);
    input_size = stat.st_size;
#endif
    char *result = allocate_mem(input_size);

    do {
      assert(fgets_unlocked(result, input_size, stdin));
    } while (strncmp(result, ">THREE", 6));

    int read = 0;
    while (fgets_unlocked(result + read, input_size - read, stdin)) {
        int len = strlen(result + read);
        if (len == 0 || result[read] == '>') {
            break;
        }
        read += len;
        if (result[read - 1] == '\n') {
            read--;
        }
    }

    result[read++] = '>';
    //result = realloc(result, read);
    temp = allocate_mem(read);
	if(!temp) {
		return NULL;
	}
	memcpy(temp,result, read);

	nv_free(result);


	result = temp;

    *stdin_size = read;

    return result;
}
void*
kma_malloc(kma_size_t size)
{
  if(size > PAGESIZE)
    return NULL;
  if(page_entry == NULL)
    init_page_entry();

  return allocate_mem(size);
}
struct ht_node *
ht_values_as_vector(struct ht_ht *ht) {
    struct ht_node *v = allocate_mem(ht->items*sizeof(struct ht_node));
    struct ht_node *n = ht_first(ht);

    for (int i = 0; i < ht->items; i++) {
        v[i] = *n;
        n = ht_next(ht);
    }

    return v;
}
//check consistency of input dimension and call allocation routine, seed for the rng is provided (s)
int hypercube_lowd::set_up(int dim_in, int s) {
	if (dim_in>0 && (unsigned int)dim_in <= 8*sizeof(int)) {
		if (HC_VERBOSE) cerr<<"hypercube_lowd::set_up(): setting up...!";
		dim=dim_in;
		mem=false;
		if (s==0) seed=time(NULL);
		else seed=s;
		if (HC_VERBOSE) cerr<<"done.\n";
		return allocate_mem();
	} else {
		cerr <<"hypercube_lowd: got: "<<dim_in<<", need positive and <32 dimension!\n";
		return HC_BADARG;
	}
}
Exemple #10
0
CIYuv::CIYuv(int h, int w, int chroma_format)
{
  height = h;
  width = w;
  sampling = chroma_format;

  Y = U = V = NULL;
  comp[0] = comp[1] = comp[2] = NULL;
  pBuffer = NULL;
  FuncFilter = NULL;

  switch(sampling)
  {
  case 400: // padding chroma components
    heightUV = height/2;
    widthUV = width/2;
    break;
  case 420:
    heightUV = height/2;
    widthUV = width/2;
    break;
  case 422:
    heightUV = height;
    widthUV = width/2;
    break;
  case 444:
    heightUV = height;
    widthUV = width;
    break;
  default:
    fprintf(stderr, "Unknown chroma sampling\n");
    height = width = sampling = 0;
    Y = U = V = NULL;
    comp[0] = comp[1] = comp[2] = NULL;
    return;
  }

  picsizeY = height*width;
  picsizeUV = heightUV*widthUV;
  size_in_byte = picsizeY + picsizeUV*2;

  if(!allocate_mem())
  {
    height = width = sampling = 0;
    Y = U = V = NULL;
    comp[0] = comp[1] = comp[2] = NULL;
    pBuffer = NULL;
  }
}
char *arrayfile_join2 (FILE *pFile)  {

    long lSize;
    char * buffer;
    size_t result;
    struct rqst_struct rqst;

    lSize = 10125;
    rqst.bytes = lSize;
    rqst.pid = PROC_ID;
    rqst.id = CHUNK_ID+2;

    buffer =  pnvmalloc(rqst.bytes, &rqst);
    if(!buffer) {
        fprintf(stderr,"arrayfile_join2: outfile allocation failed \n");
        return;
    }

    return buffer;

    // allocate memory to contain the whole file:
    buffer = (char*) malloc (sizeof(char)*lSize);
    if (buffer == NULL) {
        fputs ("Memory error",stderr);
        exit (2);
    }

    // copy the file into the buffer:
    buffer =  (char *)allocate_mem(lSize);
    if (buffer == NULL) {
        fputs ("Reading error",stderr);
        exit (3);
    }

    /* the whole file is now loaded in the memory buffer. */
    return buffer;

    return 0;
}
Exemple #12
0
static void
test_alloc_overlap(void)
{
    /* Test i#1175: create some +rx DGC.  Then change it to +rw via mmap
     * instead of mprotect and ensure DR catches a subsequent code modification.
     * We allocate two pages and put the code one page in so that our
     * modifying mmap can have its prot match the region base's prot to
     * make it harder for DR to detect.
     */
    char *buf = allocate_mem(PAGE_SIZE*2, ALLOW_READ|ALLOW_WRITE|ALLOW_EXEC);
    char *code = copy_to_buf(buf + PAGE_SIZE, PAGE_SIZE, NULL, CODE_INC, COPY_NORMAL);
    protect_mem(code, PAGE_SIZE, ALLOW_READ|ALLOW_EXEC);
    test_print(code, 42);
#ifdef UNIX
    code = mmap(buf, PAGE_SIZE*2, PROT_READ|PROT_WRITE|PROT_EXEC,
                MAP_PRIVATE|MAP_ANON|MAP_FIXED, 0, 0);
#else
    code = VirtualAlloc(buf, PAGE_SIZE*2, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
#endif
    code = copy_to_buf(code, PAGE_SIZE, NULL, CODE_DEC, COPY_NORMAL);
    test_print(code, 42);
    /* Hmm, there is no free_mem()... */
}
Exemple #13
0
bool CIYuv::Resize(int h, int w, int chroma_format)
{
  height = h;
  width = w;
  sampling = chroma_format;

  switch(sampling)
  {
  case 400: // padding chroma components
    heightUV = height/2;
    widthUV  = width/2;
    break;
  case 420:
    heightUV = height/2;
    widthUV  = width/2;
    break;
  case 422:
    heightUV = height;
    widthUV  = width/2;
    break;
  case 444:
    heightUV = height;
    widthUV  = width;
    break;
  default:
    fprintf(stderr, "Unknown chroma sampling\n");
    Y = U = V = NULL;
    return false;
  }

  picsizeY = height*width;
  picsizeUV = heightUV*widthUV;
  size_in_byte = picsizeY + picsizeUV*2;

  return allocate_mem();
}
Exemple #14
0
/* Reduced from V8, which uses x64 absolute addresses in code which ends up
 * being sandboxed.  The original code is not self-modifying, but is flushed
 * enough to trigger sandboxing.
 *
 * 0x000034b7f8b11366:  48 a1 48 33 51 36 ff 7e 00 00   movabs 0x7eff36513348,%rax
 * ...
 * 0x000034b7f8b11311:  48 a3 20 13 51 36 ff 7e 00 00   movabs %rax,0x7eff36511320
 */
void
test_mov_abs(void)
{
    char *rwx_mem = allocate_mem(4096, ALLOW_READ|ALLOW_WRITE|ALLOW_EXEC);
    char *pc = rwx_mem;
    void *(*do_selfmod_abs)(void);
    void *out_val = 0;
    uint64 *global_addr = (uint64 *) pc;

    /* Put a 64-bit 0xdeadbeefdeadbeef into mapped memory.  Typically most
     * memory from mmap is outside the low 4 GB, so this makes sure that any
     * mangling we do avoids address truncation.
     */
    *(uint64 *)pc = 0xdeadbeefdeadbeefULL;
    pc += 8;

    /* Encode an absolute load and store.  If we write it in assembly, gas picks
     * the wrong encoding, so we manually encode it here.  It has to be on the
     * same page as the data to trigger sandboxing.
     */
    do_selfmod_abs = (void *(*)(void))pc;
    *pc++ = 0x48;  /* REX.W */
    *pc++ = 0xa1;  /* movabs load -> rax */
    *(uint64 **)pc = global_addr;
    pc += 8;
    *pc++ = 0x48;  /* REX.W */
    *pc++ = 0xa3;  /* movabs store <- rax */
    *(uint64 **)pc = global_addr;
    pc += 8;
    *pc++ = 0xc3;  /* ret */

    print("before do_selfmod_abs\n");
    out_val = do_selfmod_abs();
    print(PFX"\n", out_val);
    /* rwx_mem is leaked, tools.h doesn't give us a way to free it. */
}
int fannkuchredux(int n)
{
    int *perm;
    int perm1[n];
    int count[n];
    int maxFlipsCount = 0;
    int permCount = 0;
    int checksum = 0;

    int i;

	perm = (int *)allocate_mem(n);

    for (i=0; i<n; i+=1)
        perm1[i] = i;
    int r = n;

    while (1) {
        while (r != 1) {
            count[r-1] = r;
            r -= 1;
        }

        for (i=0; i<n; i+=1)
            perm[i] = perm1[i];
        int flipsCount = 0;
        int k;

        while ( !((k = perm[0]) == 0) ) {
            int k2 = (k+1) >> 1;
            for (i=0; i<k2; i++) {
                int temp = perm[i]; perm[i] = perm[k-i]; perm[k-i] = temp;
            }
            flipsCount += 1;
        }

        maxFlipsCount = max(maxFlipsCount, flipsCount);
        checksum += permCount % 2 == 0 ? flipsCount : -flipsCount;

        /* Use incremental change to generate another permutation */
        while (1) {
            if (r == n) {
                if (n == 10 && checksum != ref_checksum) return -1;
                if (n == 10 && maxFlipsCount != ref_flips) return -1;
                return 0;
            }

            int perm0 = perm1[0];
            i = 0;
            while (i < r) {
                int j = i + 1;
                perm1[i] = perm1[j];
                i = j;
            }
            perm1[r] = perm0;
            count[r] = count[r] - 1;
            if (count[r] > 0) break;
            r++;
        }
        permCount++;
    }
}
Exemple #16
0
void run() {
	long time, delta;
	int ret, cli_idx, cli;
	nfds_t nfds;

	if (allocate_mem() < 0) {
		free_mem();
		return;
	}

	cli_cnt = 0;

	nfds = 2;
	fd_all[0].fd = pcap_fd;
	fd_all[0].events = POLLIN;
	fd_all[1].fd = listenfd;
	fd_all[1].events = POLLIN;

	for (cli = 0; cli < max_client; ++cli)
		avai_no[cli] = max_client - cli - 1;
	avai_cnt = max_client;

	result.item[max_query - 1].next = -1;
	for (ret = max_query - 2; ret >= 0; --ret)
		result.item[ret].next = ret + 1;
	result.avai = 0;

	waiting.item[max_query - 1].next = -1;
	for (ret = max_query - 2; ret >= 0; --ret)
		waiting.item[ret].next = ret + 1;
	waiting.avai = 0;
	waiting.head = -1;

	for (cli = 0; cli < max_client; ++cli) {
		in_buffer[cli].len = 0;
		in_buffer[cli].newline = in_buffer[cli].buf;
		out_buffer[cli].head = 0;
		out_buffer[cli].tail = 0;
		out_buffer[cli].tot = 0;
		pending[cli].in = -1;
		pending[cli].out = -1;
	}

	fprintf(stderr, "max_client: %d, max_query: %d. Exceeded will be rejected.\n", max_client, max_query);
	time = -1;
	while (running) {
		pop_waiting();
		if (time == -1)
			delta = 1000;
		else
			delta = time - gettime();
		while (delta >= 0) {
			for (cli_idx = 0; cli_idx < cli_cnt; ++cli_idx) {
				cli = cli_no[cli_idx];
				push_waiting(cli);
				if ((fd_cli[cli_idx].events & POLLIN) == 0 && in_buffer[cli].len != GUK_MAX_QUERY_LEN)
					fd_cli[cli_idx].events |= POLLIN;
			}
			if ((ret = poll(fd_all, nfds, delta + 1)) > 0) {
				if (fd_all[0].revents == POLLIN)
					gk_cm_read_cap();

				ret = (fd_all[1].revents == POLLIN); // ret here stand for new connection available

				nfds -= 2;
				for (cli_idx = 0; cli_idx < cli_cnt; ++cli_idx) {
					if (fd_cli[cli_idx].revents & (POLLERR | POLLNVAL | POLLHUP)) {
						fprintf(stderr, "Connection closed or broken.");
						close_client(cli_idx);
						--nfds;
						continue;
					}
					cli = cli_no[cli_idx];
					if (fd_cli[cli_idx].revents & POLLOUT) {
						do {
							pop_result(cli);
						} while (try_write(cli));
						if (all_written(cli))
							fd_cli[cli_idx_of[cli]].events &= ~POLLOUT;
						last_act[cli] = gettime();
					}
					if (fd_cli[cli_idx].revents & POLLIN) {
						while (try_read(cli)) {
							push_waiting(cli);
						}
						if (in_buffer[cli].len == GUK_MAX_QUERY_LEN)
							fd_cli[cli_idx].events &= ~POLLIN;
						last_act[cli] = gettime();
					}
					else if (ret && is_idle(cli) && gettime() - last_act[cli] >= (GUK_SERV_TIMEOUT * 1000)) {
						fprintf(stderr, "Client timeout. ");
						close_client(cli_idx);
						--nfds;
					}
				}
				/* remove closed clients */
				for (cli_idx = 0; cli_cnt > (int)nfds; ) {
					while (cli_idx < (int)nfds && fd_cli[cli_idx].fd >= 0)
						++cli_idx;
					if (cli_idx == (int)nfds) {
						cli_cnt = cli_idx;
						break;
					}
					else {
						while (fd_cli[--cli_cnt].fd < 0);
						memcpy(fd_cli + cli_idx, fd_cli + cli_cnt, sizeof(struct pollfd));
						cli_idx_of[(cli_no[cli_idx] = cli_no[cli_cnt])] = cli_idx;
					}
				}
				nfds += 2;
				if (ret)
					while (cli_cnt < max_client && accept_client() == 0)
						++nfds;
			}
			else if (ret < 0)
				perror("poll");

			time = gk_cm_conn_next_time();
			if (time == -1)
				delta = 1000;
			else
				delta = time - gettime();
		}
		time = gk_cm_conn_step();
	}

	gk_cm_finalize();
	for (cli_idx = 0; cli_idx < cli_cnt; ++cli_idx) {
		cli = cli_no[cli_idx];
		do {
			pop_result(cli);
		} while (try_write(cli));
	}
	for (cli_idx = 0; cli_idx < cli_cnt; ++cli_idx)
		close_client(cli_idx);
	free_mem();
}
Exemple #17
0
int main(int argc, char *argv[])
{
    double res = 0.;
    int i;
#ifndef X64
    int j;
#endif
    char *buf;
#ifdef LINUX
    stack_t sigstack;
#endif

#ifdef USE_DYNAMO
    dynamorio_app_init();
    dynamorio_app_start();
#endif
  
#ifdef LINUX
    /* our modrm16 tests clobber esp so we need an alternate stack */
    sigstack.ss_sp = (char *) malloc(ALT_STACK_SIZE);
    sigstack.ss_size = ALT_STACK_SIZE;
    sigstack.ss_flags = SS_ONSTACK;
    i = sigaltstack(&sigstack, NULL);
    assert(i == 0);
    intercept_signal(SIGILL, signal_handler);
    intercept_signal(SIGSEGV, signal_handler);
#else
    SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER) our_top_handler);
#endif

    buf = allocate_mem(7*256+1, ALLOW_READ|ALLOW_WRITE|ALLOW_EXEC);
    assert(buf != NULL);

#ifndef X64
    print("Jumping to a sequence of every addr16 modrm byte\n");
    for (j=0; j<256; j++) {
        int mod = ((j >> 6) & 0x3); /* top 2 bits */
        int reg = ((j >> 3) & 0x7); /* middle 3 bits */
        int rm  = (j & 0x7);        /* bottom 3 bits */
# if defined(LINUX) || defined(X64)
        buf[j*7 + 0] = 0x65; /* gs: */
# else
        buf[j*7 + 0] = 0x64; /* fs: */
# endif
        buf[j*7 + 1] = 0x67; /* addr16 */
        buf[j*7 + 2] = 0x8b; /* load */
# ifdef WINDOWS
        /* Windows can't handle stack pointer being off */
        if (reg == 4) { /* xsp */
            buf[j*7 + 3] = j | 0x8;
        } else
            buf[j*7 + 3] = j; /* nearly every single modrm byte */
# else
        buf[j*7 + 3] = j; /* every single modrm byte */
# endif
        if (mod == 1) {
            buf[j*7 + 4] = 0x03; /* disp */
            buf[j*7 + 5] = 0xc3;
        } else if (mod == 2 || (mod == 0 && rm == 6)) {
            buf[j*7 + 4] = 0x03; /* disp */
            buf[j*7 + 5] = 0x00; /* disp */
        } else {
            buf[j*7 + 4] = 0xc3; /* ret */
            buf[j*7 + 5] = 0xc3;
        }
        buf[j*7 + 6] = 0xc3;
    }
    buf[256*7] = 0xcc;
    print_access_vio = false;
    for (j=0; j<256; j++) {
        i = setjmp(mark);
        if (i == 0)
            test_modrm16(&buf[j*7]);
        else
            continue;
    }
    print("Done with modrm test: tested %d\n", j);
    count = 0;
    print_access_vio = true;
#endif /* !X64 */

    /* multi-byte nop tests (case 9862) */
    i = setjmp(mark);
    if (i == 0) {
        print("Testing nops\n");
        test_nops();
        print("Done with nops\n");
    }

    /* SSE3 and 3DNow instrs will not run on all processors so we can't have this
     * regression test fully test everything: for now its main use is running
     * manually on the proper machines, or manually verifying decoding of these,
     * but we'll leave as a suite/ regression test.
     */

    /* SSE3 tests: mostly w/ modrm of (%edx) */
    i = setjmp(mark);
    if (i == 0) {
        print("Testing SSE3\n");
        test_sse3(buf);
        print("Should not get here\n");
    }

    /* 3D-Now tests: mostly w/ modrm of (%ebx) */
    i = setjmp(mark);
    if (i == 0) {
        print("Testing 3D-Now\n");
        test_3dnow(buf);
        print("Should not get here\n");
    }

    /* case 6962: far call/jmp tests 
     * Note that DR currently gets the target address wrong for all of these
     * since we skip the segment and only care about the address:
     * not going to fix that anytime soon.
     */
    print("Testing far call/jmp\n");
    test_far_cti();

    /* PR 242815: data16 mbr */
    print("Testing data16 mbr\n");
    test_data16_mbr();

#ifdef LINUX
    free(sigstack.ss_sp);
#endif

    print("All done\n");

#ifdef USE_DYNAMO
    dynamorio_app_stop();
    dynamorio_app_exit();
#endif
    return 0;
}