예제 #1
0
std::string Color::to_ppm(double max){
    std::string ri = ntos(round(r * max));
    std::string gi = ntos(round(g * max));
    std::string bi = ntos(round(b * max));
    return ri + " " + gi + " " + bi;
    
}
예제 #2
0
std::string Color::to_ppm(double oldmax, double newmax, double gamma){
    //step 1: normalize to between 0 and 1
    double ri = pow(r / oldmax, 1/gamma) * newmax;
    double gi = pow(g / oldmax, 1/gamma) * newmax;
    double bi = pow(b / oldmax, 1/gamma) * newmax;
    return ntos(round(ri)) + " " + ntos(round(gi)) + " " + ntos(round(bi));
}
예제 #3
0
파일: hamt.c 프로젝트: 4n3w/dump
void *hamt_delete(struct hamt_root *root, uint128_t *hash)
{
	if (unlikely(ston(root->slot) == NULL)) {
		return NULL;
	}

	struct hamt_state s;
        s.level = 0;
        s.ptr[0] = &root->slot;

	void *found_item = __hamt_search(root, hash, &s);
	if (unlikely(found_item == NULL)) {
		return NULL;
	}
	if (unlikely(s.level == 0)) {
		root->slot = (struct hamt_slot){0};
		goto done;
	}
	struct hamt_slot *found_slot = s.ptr[s.level];
	s.level--;

	struct hamt_node *node = ston(*s.ptr[s.level]);

	int slice = slice_get(*hash, s.level);
	if (set_count(node->mask) != 2) {
		*s.ptr[s.level] = ntos(__hamt_del_node(root, node, slice));
		goto done;
	} else { // set_count == 2
		struct hamt_slot other_slot = \
			__hamt_get_other_slot(node, found_slot);
		if(!is_leaf(&other_slot)) {
			uint64_t other_slice = set_first(set_del(node->mask, slice));
			__hamt_free_node(root, node);
			*s.ptr[s.level] = ntos(__hamt_new_node1(root, other_slice, other_slot));
			goto done;
		} else {
			while (1) {
				__hamt_free_node(root, node);
				if (unlikely(s.level == 0)) {
					root->slot = other_slot;
					goto done;
				}

				s.level--;
				node = ston(*s.ptr[s.level]);
				if (set_count(node->mask) != 1) {
					break;
				}
			}
			slice = slice_get(*hash, s.level);
			int slot = set_slot_number(node->mask, slice);
			node->slots[slot] = other_slot;
			goto done;
		}
	}
done:
	return found_item;
}
예제 #4
0
int FAT::flush()
{
  message("FAT flush\n");

  // How many entries fit into a disk block?

  int entries_per_block = disk.block_size() / sizeof(int);

  // Save the FAT to disk

  for (int block_num = 0; block_num < fat_num_blocks(); ++block_num)
  {
    int index = entries_per_block * block_num;
    int entries;
    
    if (index + entries_per_block > disk.num_blocks())
      entries = disk.num_blocks() - index;
    else
      entries = entries_per_block;

    char buf[MAX_BLOCK_SIZE];

    for (int pos = 0; pos < entries; ++pos)
      ntos(buf + sizeof(int)*pos, entry[index + pos]);

    if (disk.write(block_num, buf) == DISK_ERROR)
      return DISK_ERROR;
  }

  return DISK_OK;
}
예제 #5
0
파일: hamt.c 프로젝트: 4n3w/dump
static struct hamt_node *__hamt_add_slot(struct hamt_root *root,
					 struct hamt_slot *slot_ptr,
					 void *item, uint128_t *item_hash,
					 int level)
{
	uint64_t slice = slice_get(*item_hash, level);

	struct hamt_node *old_node = ston(*slot_ptr);
	int old_size = set_count(old_node->mask);
	int new_size = old_size + 1;
	struct hamt_node *node = __hamt_new_node(root,
						 set_add(old_node->mask, slice),
						 new_size);
	*slot_ptr = ntos(node);

	int slot = set_slot_number(node->mask, slice);

	memcpy(&node->slots[0], &old_node->slots[0],
	       sizeof(struct hamt_slot)*slot);
	memcpy(&node->slots[slot+1], &old_node->slots[slot],
	       sizeof(struct hamt_slot)*(old_size-slot));
	node->slots[slot] = item_to_slot(item);

	__hamt_free_node(root, old_node);
	return node;
}
예제 #6
0
int RPC::call(const char command[5], int block_num, char *buf) const
{
  if (sock < 0)
    return DISK_ERROR;

  char packet[NDISK_BLOCK_SIZE + 8];

  // Add the command to the packet header
  memcpy(packet, command, 4);

  // Add the block_num parameter to the packet header
  ntos(packet + 4, block_num);
  
  // Add the block to the packet
  if (buf)
    memcpy(packet + 8, buf, NDISK_BLOCK_SIZE);

  size_t len = NDISK_BLOCK_SIZE + 8;
  char *msg = packet;

  // Write the packet (with 8-byte header)
  do
  {
    ssize_t nwritten = send(sock, msg, len, 0);

    if (nwritten < 0)
      return DISK_ERROR;

    len -= nwritten;
    msg += nwritten;
  }
  while (len > 0);

  len = NDISK_BLOCK_SIZE + 8;
  msg = packet;

  // Read the packet (with 8-byte header)
  do
  {
    ssize_t nread = recv(sock, msg, len, 0);

    if (nread <= 0)
      return DISK_ERROR;

    len -= nread;
    msg += nread;
  }
  while (len > 0);

  if (buf){
      //buf = (char *) malloc(NDISK_BLOCK_SIZE);
      //buf = (char*) (packet+8); 
      if(strcmp(command, "WRTE")!=0){ 
        //std::cout<<"buf="<<buf<<", command is  "<<command<<std::endl;
        memcpy(buf, packet + 8, NDISK_BLOCK_SIZE);
      }
      //free(buf);
  }
  return DISK_OK;
}
예제 #7
0
파일: ohamt.c 프로젝트: pombredanne/ydb
static void __ohamt_delete(struct ohamt_root *root, uint128_t hash,
			   struct ohamt_state *s)
{
	if (unlikely(s->level == 0)) {
		root->slot = (struct ohamt_slot){0};
		goto done;
	}
	struct ohamt_slot *found_slot = s->ptr[s->level];
	s->level--;

	struct ohamt_node *node = ston(*s->ptr[s->level]);

	int slice = slice_get(hash, s->level);
	if (set_count(node->mask) != 2) {
		*s->ptr[s->level] = ntos(__ohamt_del_node(root, node, slice));
		goto done;
	} else { // set_count == 2
		struct ohamt_slot other_slot = \
			__ohamt_get_other_slot(node, found_slot);
		if(!is_leaf(&other_slot)) {
			uint64_t other_slice = set_first(set_del(node->mask, slice));
			__ohamt_free_node(root, node);
			*s->ptr[s->level] = ntos(__ohamt_new_node1(root, other_slice, other_slot));
			goto done;
		} else {
			while (1) {
				__ohamt_free_node(root, node);
				if (unlikely(s->level == 0)) {
					root->slot = other_slot;
					goto done;
				}

				s->level--;
				node = ston(*s->ptr[s->level]);
				if (set_count(node->mask) != 1) {
					break;
				}
			}
			slice = slice_get(hash, s->level);
			int slot = set_slot_number(node->mask, slice);
			node->slots[slot] = other_slot;
			goto done;
		}
	}
done:
	return;
}
예제 #8
0
파일: arp.c 프로젝트: gnarlie/bad-os-64
static void arp_request(struct netdevice * device, uint32_t targetIp) {
    sbuff * buf = ethernet_sbuff_alloc(sizeof(struct arp_packet));
    add_ref(buf);

    struct arp_packet * arp = (struct arp_packet*)buf->head;
    arp->htype = ntos(1);
    arp->ptype = ntos(0x0800);
    arp->hlen = 6;
    arp->plen = 4;
    arp->operation = ntos(1);
    memcpy(arp->senderMac, device->mac, 6);
    arp->senderIp = ntol(device->ip);
    bzero(arp->targetMac, 6);
    arp->targetIp = ntol(targetIp);

    ethernet_send(buf, 0x0806, BROADCAST_MAC, device);
    release_ref(buf, sbuff_free);
}
예제 #9
0
파일: arp.c 프로젝트: gnarlie/bad-os-64
static void reply(struct netdevice* dev, mac target, uint32_t ip, int broadcast) {
    sbuff * buf = raw_sbuff_alloc(sizeof(struct ethernet_frame) + sizeof(struct arp_packet));
    add_ref(buf);
    sbuff_push(buf, sizeof(struct ethernet_frame));

    struct arp_packet * arp = (struct arp_packet*)buf->head;
    arp->htype = ntos(1);
    arp->ptype = ntos(0x0800);
    arp->hlen = 6;
    arp->plen = 4;
    arp->operation = ntos(2);
    memcpy(arp->senderMac, dev->mac, 6);
    arp->senderIp = ntol(dev->ip);
    memcpy(arp->targetMac, target, 6);
    arp->targetIp = ntol(ip);

    ethernet_send(buf, 0x0806, broadcast ? BROADCAST_MAC : target, dev);
    release_ref(buf, sbuff_free);
}
예제 #10
0
파일: ohamt.c 프로젝트: pombredanne/ydb
static void __ohamt_insert_leaf(struct ohamt_root *root,
			       struct ohamt_state *s,
			       uint128_t item_hash, uint64_t item,
			       uint128_t leaf_hash, uint64_t leaf)
{
        int leaf_slice = slice_get(leaf_hash, s->level);
        int item_slice = slice_get(item_hash, s->level);
        if (leaf_slice != item_slice) {
		*s->ptr[s->level] = ntos(__ohamt_new_node2(root,
                                                          item, item_slice,
                                                          leaf, leaf_slice));
        } else {
                struct ohamt_node *node =  __ohamt_new_node1(root,
							     item_slice,
							     item_to_slot(OHAMT_NOT_FOUND));
                *s->ptr[s->level] = ntos(node);
                s->ptr[s->level + 1] = &node->slots[0];
                s->level += 1;
                __ohamt_insert_leaf(root, s, item_hash, item, leaf_hash, leaf);
        }
}
예제 #11
0
파일: hamt.c 프로젝트: 4n3w/dump
static inline void __hamt_insert_leaf(struct hamt_root *root,
                                      struct hamt_state *s,
                                      uint128_t *item_hash, void *item,
                                      uint128_t *leaf_hash, void *leaf)
{
        int leaf_slice = slice_get(*leaf_hash, s->level);
        int item_slice = slice_get(*item_hash, s->level);
        if (leaf_slice != item_slice) {
		*s->ptr[s->level] = ntos(__hamt_new_node2(root,
                                                          item, item_slice,
                                                          leaf, leaf_slice));
        } else {
                struct hamt_node *node =  __hamt_new_node1(root,
                                                           item_slice,
							   item_to_slot(NULL));
                *s->ptr[s->level] = ntos(node);
                s->ptr[s->level + 1] = &node->slots[0];
                s->level += 1;
                __hamt_insert_leaf(root, s, item_hash, item, leaf_hash, leaf);
        }
}
예제 #12
0
파일: arp.c 프로젝트: gnarlie/bad-os-64
void arp_packet(struct netdevice* dev, const uint8_t * data) {
    struct arp_packet * arp = (struct arp_packet*) data;

    if (ntol(arp->targetIp) != dev-> ip) return;

    int request = ntos(arp->operation) == 1;
    if (request) {
        // store(arp->senderMac, ntol(arp->senderIp));
        reply(dev, arp->senderMac, ntol(arp->senderIp), 0);
    }
    else {
        arp_store(arp->senderMac, ntol(arp->senderIp));
    }
}
예제 #13
0
파일: terminal.c 프로젝트: SlySven/tintin
void init_screen_size(struct session *ses)
{
	int top, bot;
	struct winsize screen;

	top = ses->top_row == 0 ? 1 : ses->top_row;
	bot = ses->bot_row == 0 ? 0 : ses->rows - ses->bot_row;

	if (ses == gts)
	{
		if (ioctl(0, TIOCGWINSZ, &screen) == -1)
		{
			ses->rows = SCREEN_HEIGHT;
			ses->cols = SCREEN_WIDTH;
		}
		else
		{
			ses->rows = screen.ws_row;
			ses->cols = screen.ws_col;
		}
		SET_BIT(gtd->flags, TINTIN_FLAG_RESETBUFFER);
	}
	else
	{
		ses->rows = gts->rows;
		ses->cols = gts->cols;
	}

	ses->top_row = top;
	ses->bot_row = ses->rows - bot;

	if (HAS_BIT(ses->flags, SES_FLAG_SPLIT))
	{
		init_split(ses, ses->top_row, ses->bot_row);
	}
	check_all_events(ses, SUB_ARG|SUB_SEC, 0, 2, "SCREEN RESIZE", ntos(ses->cols), ntos(ses->rows));
}
예제 #14
0
struct session *new_session(struct session *ses, char *name, char *command, int pid, int socket)
{
	int cnt = 0;
	struct session *newsession;

	push_call("new_session(%p,%p,%p,%d,%d)",ses,name,command,pid,socket);

	for (newsession = gts ; newsession ; newsession = newsession->next)
	{
		if (!strcmp(newsession->name, name))
		{
			display_puts(ses, "THERE'S A SESSION WITH THAT NAME ALREADY.");

			if (close(socket) == -1)
			{
				syserr("close in new_session");
			}

			kill(pid, SIGKILL);

			pop_call();
			return ses;
		}
	}

	newsession                = (struct session *) calloc(1, sizeof(struct session));

	newsession->name          = strdup(name);
	newsession->command       = strdup(command);
	newsession->pid           = pid;

	newsession->group         = strdup(gts->group);
	newsession->flags         = gts->flags;

	LINK(newsession, gts->next, gts->prev);

	for (cnt = 0 ; cnt < LIST_MAX ; cnt++)
	{
		newsession->list[cnt] = copy_list(newsession, gts->list[cnt], cnt);
	}

	newsession->rows          = gts->rows;
	newsession->cols          = gts->cols;

	display_printf(ses, "#TRYING TO LAUNCH '%s' RUNNING '%s'.", newsession->name, newsession->command);

	gtd->ses = newsession;

	SET_BIT(newsession->flags, SES_FLAG_CONNECTED|SES_FLAG_RUN);

	DEL_BIT(newsession->flags, SES_FLAG_LOCALECHO);

	gtd->ses = newsession;

	gtd->ses->socket = socket;

	check_all_events(ses, SUB_ARG|SUB_SEC, 0, 3, "SESSION CONNECTED", ses->name, ses->command, ntos(ses->pid));

	pop_call();
	return gtd->ses;
}
예제 #15
0
파일: ufo.c 프로젝트: ainehanta/J3jikken
int main(void)
{
  unsigned int score, high_score;
  char score_s[MAXDIGITNUM+1];

  ROMEMU();
  USE_UI();
  timer_pri_set(0,1);
  random_init();
  lcd_init();
  key_init();
  timer_init();
  sound_init();
  timer_set(1,100);
  timer_start(1);
  ENINT();

  lcd_cursor(0,0);
  lcd_printstr(" 0:Game Start   ");
  lcd_cursor(0,1);
  lcd_printstr(" *:High Score   ");
  high_score = 0;

  lcd_cursor(0,0);

  while(1)
  {
    if (key_check(10) == KEYON){     /* *キー:ハイスコア表示 */
      lcd_cursor(0,0);                   /* LCD にハイスコア表示 */
      lcd_printstr(" High Score is  ");
      lcd_cursor(0,1);
      lcd_printstr("                ");
      lcd_cursor(0,1);
      lcd_printstr(ntos(high_score,score_s));
    }
    if (key_check(10) == KEYOFF){
      lcd_cursor(0,0);
      lcd_printstr(" 0:Game Start   ");
      lcd_cursor(0,1);
      lcd_printstr(" *:High Score   ");
    }
    if (key_check(11) == KEYON){      /* 0キー:ゲームスタート */
	  zanki = 5;
      lcd_cursor(0,0);                   /* LCD に操作方法表示 */
      lcd_printstr("*:Sight  0:Trig.");
      score = game_start();              /* ゲームスタート */
      lcd_cursor(0,1);                   /* 得点表示欄のクリア */
      lcd_printstr("                ");
      if (score > high_score){           /* ハイスコアのとき */
        high_score = score;                /* ハイスコア登録 */
        lcd_cursor(0,0);                   /* ハイスコア表示 */
        lcd_printstr(" High Score !!! ");
        lcd_cursor(0,1);
        lcd_printstr(ntos(high_score,score_s));
      } else {                           /* ハイスコアでないとき*/
        lcd_cursor(0,0);                   /* スコアを表示 */
        lcd_printstr(" Your Score ... ");
        lcd_cursor(0,1);
        lcd_printstr(ntos(score,score_s));
      }
      n_time = 0;
      while (n_time < WAITFEWSEC);       /* 得点表示後にちょっと待つ */
      lcd_cursor(0,0);                     /* LCD にメッセージ表示 */
      lcd_printstr(" 0:Game Start   ");
      lcd_cursor(0,1);
      lcd_printstr(" *:High Score   ");
    }
  }
}
예제 #16
0
파일: status.c 프로젝트: raph38130/rplgm
int sys_status(int n,char *result)
{
int i, val;
char s[30];
PROCESS *p;

val=0;
*result=0;

switch(n) {
  
/*   case statusBUDDY : 
   		check_mem();
	     	break;
*/
   case statusSEMA : for(i=0;i<NSEMA;i++)
                 if(SEMA_ARRAY[i].s_status == VALID) {
                     strcat(result,"semaphore ");
                     ntos(i,s);
                     strcat(result,s);
		     strcat(result," ");
		     strcat(result,SEMA_ARRAY[i].s_name);
                     strcat(result," count ");
                     n_htos(SEMA_ARRAY[i].s_count,s);
                     strcat(result,s);
	     	     nl;
                     }
		 break;
   case statusSLEEP :
	      strcat(result,"sleeping");
	      nl;
              p = SLEEP;
              while(p != NULL) {
		   strcat(result,p->name);
		   strcat(result," ");
		   ntos(p->delay,s);
		   strcat(result,s);
	     	nl;
		   p = p->s_next;
   		   }
		   break;
		   
   case statusDESCR : 
	     	strcat(result,"file descriptor : slot/device");
	     	nl;
		for(i = 0;i<NFD;i++)
		   if (fdtab[i].libre == FDUSED) {
			strcat(result,"file desc. ");
			ntos(i,s);
			strcat(result,s);
			strcat(result,"/");
			ntos(fdtab[i].device, s);
			strcat(result,s);
	     		nl;
			}
	      	strcat(result,"device descriptor : devnum major/minor idata/odata");
	     	nl;
		for(i = 0;i<NDEV;i++) {
			strcat(result,"devnum ");
			ntos(i,s);
			strcat(result,s);
			strcat(result," ");
			ntos(devtab[i].major,s);
			strcat(result,s);
			strcat(result,"/");
			ntos(devtab[i].minor,s);
			strcat(result,s);
			strcat(result," ");
			ntos(tty[devtab[i].minor].idata,s);
			strcat(result,s);
			strcat(result,"/");
			ntos(tty[devtab[i].minor].odata,s);
			strcat(result,s);
	     nl;
			}
              break;
   case statusPROCS : 
		for(i=0;i<NBPROC;i++) 
		   if (PROCS_ARRAY[i].status != INEXISTANT) {
                      ntos(i,s);
		      strcat(result,s);
		      strcat(result," : ");
		      strcat(result,PROCS_ARRAY[i].name);
                      strcat(result," priorité ");
                      ntos(PROCS_ARRAY[i].prio,s);
                      strcat(result,s);
                 switch(PROCS_ARRAY[i].status) {
                       case SUSPENDU : 	strcat(result," suspendu");
                                       	break;
                       case SLEEPING : 	strcat(result," sleeping");
                                       	break;
                       case ACTIVABLE : strcat(result," activable");
                                        break;
                       case INEXISTANT : strcat(result," inexistant");
                                        break;
                       case WAITING : 	strcat(result," waiting sur ");
					strcat(result,((SEMAPHORE*) PROCS_ARRAY[i].sem)->s_name);
                                        break;
		       }
 	     	nl;
               }
                break;

   default : strcat(result,"choix non valide");
	     nl;
   }
return 0;
}
예제 #17
0
파일: main.c 프로젝트: SlySven/tintin
int main(int argc, char **argv)
{
	int greeting = TRUE;

	#ifdef SOCKS
		SOCKSinit(argv[0]);
	#endif

	if (signal(SIGTERM, trap_handler) == BADSIG)
	{
		syserr("signal SIGTERM");
	}

	if (signal(SIGSEGV, trap_handler) == BADSIG)
	{
		syserr("signal SIGSEGV");
	}

	if (signal(SIGHUP, trap_handler) == BADSIG)
	{
		syserr("signal SIGHUP");
	}

	if (signal(SIGABRT, abort_handler) == BADSIG)
	{
		syserr("signal SIGTERM");
	}

	if (signal(SIGINT, abort_handler) == BADSIG)
	{
		syserr("signal SIGINT");
	}

	if (signal(SIGTSTP, suspend_handler) == BADSIG)
	{
		syserr("signal SIGSTOP");
	}

	if (signal(SIGPIPE, pipe_handler) == BADSIG)
	{
		syserr("signal SIGPIPE");
	}

	if (signal(SIGWINCH, winch_handler) == BADSIG)
	{
		syserr("signal SIGWINCH");
	}

/*
	if (getenv("HOME") != NULL)
	{
		char filename[256];

		sprintf(filename, "%s/%s", getenv("HOME"), HISTORY_FILE);

		read_history(gts, filename);
	}
*/

	srand(time(NULL));

	if (argc > 1)
	{
		int c;

		while ((c = getopt(argc, argv, "e: G h r: s: t: v")) != EOF)
		{
			if (c == 'G')
			{
				greeting = FALSE;
			}
		}

		optind = 1;
	}

	init_tintin(greeting);

	if (argc > 1)
	{
		int c;

		optind = 1;

		while ((c = getopt(argc, argv, "e: G h r: s: t: v")) != EOF)
		{
			switch (c)
			{
				case 'e':
					gtd->ses = script_driver(gtd->ses, -1, optarg);
					break;

				case 'G':
					break;

				case 'h':
					tintin_printf(NULL, "Usage: %s [OPTION]... [FILE]...", argv[0]);
					tintin_printf(NULL, "");
					tintin_printf(NULL, "  -e  Execute given command.");
					tintin_printf(NULL, "  -G  Don't show the greeting screen.");
					tintin_printf(NULL, "  -h  This help section.");
					tintin_printf(NULL, "  -r  Read given file.");
					tintin_printf(NULL, "  -t  Set given title.");
					tintin_printf(NULL, "  -v  Enable verbose mode.");

					restore_terminal();
					exit(1);
					break;

				case 'r':
					gtd->ses = do_read(gtd->ses, optarg);
					break;

				case 't':
					printf("\033]0;%s\007", optarg);
					break;

				case 's':
					srand((unsigned int) atoll(optarg));
					break;

				case 'v':
					do_configure(gtd->ses, "{VERBOSE} {ON}");
					break;

				default:
					tintin_printf(NULL, "Unknown option '%c'.", c);
					break;
			}
		}

		if (argv[optind] != NULL)
		{
			gtd->ses = do_read(gtd->ses, argv[optind]);
		}
	}
	check_all_events(gts, SUB_ARG|SUB_SEC, 0, 2, "PROGRAM START", CLIENT_NAME, CLIENT_VERSION);
	check_all_events(gts, SUB_ARG|SUB_SEC, 0, 2, "SCREEN RESIZE", ntos(gts->cols), ntos(gts->rows));

	mainloop();

	return 0;
}
예제 #18
0
int RPC::dispatch(Disk& disk)
{
  char buf[NDISK_BLOCK_SIZE];
  char packet[NDISK_BLOCK_SIZE + 8];

  size_t len = NDISK_BLOCK_SIZE + 8;
  char *msg = packet;

  if (disk.block_size() != NDISK_BLOCK_SIZE)
    return DISK_ERROR;

  // Read the packet (with 8-byte header)
  do
  {
    ssize_t nread = recv(sock, msg, len, 0);

    if (nread <= 0)
      return DISK_ERROR;

    len -= nread;
    msg += nread;
  }
  while (len > 0);

  // Get the command from the packet's first four bytes
  char command[5];
  memcpy(command, packet, 4);
  command[4] = '\0';

  // Get the block number parameter from the packet
  int block_num = ston(packet + 4);

  if (!strcmp(command, "NUMB"))
  {
    // Write num blocks into packet data
    ntos(packet + 8, disk.num_blocks());
  }
  else if (!strcmp(command, "FRMT"))
  {
    disk.format(block_num);
  }
  else if (!strcmp(command, "READ"))
  {
    disk.read(block_num, buf);
    memcpy(packet + 8, buf, NDISK_BLOCK_SIZE);
  }
  else if (!strcmp(command, "WRTE"))
  {
    memcpy(buf, packet + 8, NDISK_BLOCK_SIZE);
    disk.write(block_num, buf);
  }
  else
  {
    message1("Unknown RPC command %s\n", command);
  }

  message2("RPC command %s(%d)\n", command, block_num);

  len = NDISK_BLOCK_SIZE + 8;
  msg = packet;

  // Write the packet (with 8-byte header)
  do
  {
    ssize_t nwritten = send(sock, msg, len, 0);

    if (nwritten < 0)
      return DISK_ERROR;

    len -= nwritten;
    msg += nwritten;
  }
  while (len > 0);

  return DISK_OK;
}
예제 #19
0
void cleanup_session(struct session *ses)
{
	push_call("cleanup_session(%p)",ses);

	if (ses == gtd->update)
	{
		gtd->update = ses->next;
	}

	UNLINK(ses, gts->next, gts->prev);

	if (ses->socket)
	{
		if (close(ses->socket) == -1)
		{
			syserr("close in cleanup");
		}

		if (HAS_BIT(ses->flags, SES_FLAG_RUN))
		{
			kill(ses->pid, SIGKILL);
		}

		DEL_BIT(ses->flags, SES_FLAG_CONNECTED);
	}

	check_all_events(ses, SUB_ARG|SUB_SEC, 0, 3, "SESSION DISCONNECTED", ses->name, ses->command, ntos(ses->pid));

	display_printf(gtd->ses, "#SESSION '%s' DIED.", ses->name);

	if (ses == gtd->ses)
	{
		gtd->ses = newactive_session();
	}

	if (ses->logfile)
	{
		fclose(ses->logfile);
	}

	if (ses->logline)
	{
		fclose(ses->logline);
	}

	LINK(ses, gtd->dispose_next, gtd->dispose_prev);

	pop_call();
	return;
}