void
GsCloseSocket(void)
{
#if !HELLOOS
if(un_sock != -1)
close(un_sock);
un_sock = -1;
unlink(GR_NAMED_SOCKET);
#else /*!HELLOS*/
if(un_sock != -1)
bucket_close(un_sock);
un_sock = -1;
#endif /*!HELLOS*/
}
/*
* This is used to drop a client when it is detected that the connection to it
* has been lost.
*/
void
GsDropClient(int fd)
{
GR_CLIENT *client;
if((client = GsFindClient(fd))) { /* If it exists */
#if !HELLOOS
close(fd); /* Close the socket */
#else
#if !NONETWORK
bucket_close(fd);
#endif
#endif
GsDestroyClientResources(client);
if(client == root_client)
root_client = client->next;
/* Link the prev to the next */
if(client->prev) client->prev->next = client->next;
/* Link the next to the prev */
if(client->next) client->next->prev = client->prev;
#if HAVE_SHAREDMEM_SUPPORT
if ( client->shm_cmds != 0 ) {
/* Free shared memory */
shmctl(client->shm_cmds_shmid,IPC_RMID,0);
shmdt(client->shm_cmds);
}
#endif
GsPrintResources();
free(client); /* Free the structure */
clipwp = NULL; /* reset clip window*/
--connectcount;
} else EPRINTF("nano-X: trying to drop non-existent client %d.\n", fd);
}
// this function will take the current array, and put it aside, creating a new array based on the
// new mask supplied (we can only make the mask bigger, and cannot shrink it).
// We create a new array, and for each entry, we compare it against the old mask, and use
// the data for that hash from the old list.
// NOTE: We may be starting off with an empty lists. If this is the first time we've
// received some hashmasks. To implement this easily, if we dont already have hashmasks, we
// may need to create one that has a dummy entry in it.
void buckets_split_mask(hash_t current_mask, hash_t new_mask)
{
bucket_t **newbuckets = NULL;
bucket_t **oldbuckets = NULL;
int i;
int index;
assert(new_mask > current_mask);
logger(LOG_INFO, "Splitting Mask: Old Mask: %#llx, New Mask; %#llx", current_mask, new_mask);
// grab a copy of the existing buckets as the 'oldbuckets';
oldbuckets = _buckets;
_buckets = NULL;
// make an appropriate sized new buckets list;
newbuckets = malloc(sizeof(bucket_t *) * (new_mask+1));
assert(newbuckets);
// go through every hash for this mask.
for (i=0; i<=new_mask; i++) {
// determine what the old index is.
index = i & current_mask;
// create the new bucket ONLY if we already have a bucket object for that index.
if (oldbuckets == NULL || oldbuckets[index] == NULL) {
newbuckets[i] = NULL;
}
else {
// we have a bucket for this old index. So we need to create a new one for this index.
newbuckets[i] = bucket_new(i);
assert(newbuckets[i]->data);
assert(newbuckets[i]->data->next == NULL);
assert(oldbuckets[index]->data);
assert(oldbuckets[index]->data->ref > 0);
newbuckets[i]->data->next = oldbuckets[index]->data;
oldbuckets[index]->data->ref ++;
assert(newbuckets[i]->hashmask == i);
newbuckets[i]->level = oldbuckets[index]->level;
newbuckets[i]->source_node = oldbuckets[index]->source_node;
newbuckets[i]->backup_node = oldbuckets[index]->backup_node;
newbuckets[i]->logging_node = oldbuckets[index]->logging_node;
newbuckets[i]->primary_node = oldbuckets[index]->primary_node;
newbuckets[i]->secondary_node = oldbuckets[index]->secondary_node;
assert(data_in_transit() == 0);
}
}
assert(_mask >= 0);
assert(new_mask > _mask);
_mask = new_mask;
// clean up the old buckets list.
if (oldbuckets) {
for (i=0; i<=_mask; i++) {
if (oldbuckets[i]) {
assert(oldbuckets[i]->data);
assert(oldbuckets[i]->data->ref > 1);
oldbuckets[i]->data->ref --;
assert(oldbuckets[i]->data->ref > 0);
oldbuckets[i]->data = NULL;
bucket_close(oldbuckets[i]);
}
}
}
_buckets = newbuckets;
assert(_buckets);
}
int tst_bucket()
{
int fd;
char s[16];
int rc;
char *buffer;
int j;
fd_set fdset;
int fdsize=0;
rc=fd=bucket_open();
if(rc<0) {
display_puts("open error=");
int2dec(-rc,s);
display_puts(s);
display_puts("\n");
return 1;
}
rc=bucket_connect(fd, BKT_QNM_BUCKET, BKT_SRV_BUCKET);
if(rc<0) {
display_puts("connect error=");
int2dec(-rc,s);
display_puts(s);
display_puts("\n");
return 1;
}
buffer=malloc(4096);
memcpy(buffer,"ABC",3);
rc=bucket_send(fd, buffer, 3);
if(rc<0) {
display_puts("send error=");
int2dec(-rc,s);
display_puts(s);
display_puts("\n");
return 1;
}
memcpy(buffer,"DEF",3);
rc=bucket_send(fd, buffer, 3);
if(rc<0) {
display_puts("send error=");
int2dec(-rc,s);
display_puts(s);
display_puts("\n");
return 1;
}
// rc=bucket_shutdown(fd);
// if(rc<0) {
// display_puts("shutdown error=");
// int2dec(-rc,s);
// display_puts(s);
// display_puts("\n");
// return 1;
// }
rc=bucket_shutdown(fd);
j=0;
while(j<5) {
display_puts("receiving(client)...");
fdsize=max(fdsize,fd);
FD_ZERO(&fdset);
FD_SET(fd,&fdset);
rc=bucket_select(fdsize+1,&fdset, 0);
if(rc<0) {
display_puts("select error=");
int2dec(-rc,s);
display_puts(s);
display_puts("\n");
return 1;
}
display_puts("\n");
rc=bucket_recv(fd, buffer, 6);
if(rc<0) {
display_puts("recv error=");
int2dec(-rc,s);
display_puts(s);
display_puts("\n");
return 1;
}
display_puts("received(client) bucket:");
int2dec(rc,s);
display_puts(s);
display_puts("byte.(");
buffer[rc]=0;
display_puts(buffer);
display_puts(")\n");
if(rc==0)
break;
syscall_wait(100);
j++;
}
rc=bucket_close(fd);
display_puts("done(client)\n");
return 0;
}
