vect.c

NAT打洞

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "vect.h"
#include "error_handler.h"
#if defined(WIN32) || defined(__WIN32__)
#include <string.h>
#else
#include <sys/sem.h>
#endif

void vector_connect(VECTOR *v);
void vector_disconnect(VECTOR *v);
void lock_vector(VECTOR *v);
void unlock_vector(VECTOR *v);
int upsize_vector(VECTOR *v);
void _vector_add(VECTOR *v, void* item);
void _vector_insert(VECTOR *v, void* item, unsigned i);
void _vector_delete(VECTOR *v, unsigned i);
void _print_item(VECTOR *v, void* name, char *file, int line, void* item);

VECTOR *create_vector(unsigned initial_capacity, unsigned width, int (__cdecl *cmp)(const void*, const void*)){
  VECTOR *result = (VECTOR *)malloc(sizeof(VECTOR));
  memset(result, 0, sizeof(VECTOR));
#if !defined(WIN32) && !defined(__WIN32__)
  result->lock = semget(get_key(), 1, 0666 | IPC_CREAT | IPC_EXCL);
  if(result->lock == -1){
    handle_error(__FILE__, __LINE__);
		exit(0);
  }
#else
	InitializeCriticalSection(&result->lock);
#endif
  memset(result->flags, 0, sizeof(unsigned ) * 4);
	result->data = (char*)malloc(width * initial_capacity);
  memset(result->data, 0, width * initial_capacity);
  result->flags[VECTOR_CAPACITY_FLAG] = initial_capacity;

  result->flags[VECTOR_SIZE_FLAG] = 0;
  result->flags[VECTOR_ITEM_WIDTH_FLAG] = width;
  result->compare = cmp;

  return result;
}

void lock_vector(VECTOR *v){
#if !defined(WIN32) && !defined(__WIN32__)
	struct sembuf sops;
  sops.sem_num = 0;
  sops.sem_op = 0;
  sops.sem_flg = 0;
	semop(v->lock, &sops, 1);
  sops.sem_op = 1;
	semop(v->lock, &sops, 1);
#else
  EnterCriticalSection(&v->lock);
#endif
}

void unlock_vector(VECTOR *v){
#if !defined(WIN32) && !defined(__WIN32__)
	struct sembuf sops;
  sops.sem_num = 0;
  sops.sem_op = -1;
  sops.sem_flg = 0;
	semop(v->lock, &sops, 1);
#else
  LeaveCriticalSection(&v->lock);
#endif
}

void delete_vector(VECTOR *v){
#if !defined(WIN32) && !defined(__WIN32__)
	struct shmid_ds buf;
#endif
  lock_vector(v);
	free(v->data);
#if !defined(WIN32) && !defined(__WIN32__)
  if(semctl(v->lock, IPC_RMID, 0, 0) == -1){
    handle_error(__FILE__, __LINE__);
		exit(0);
  }
#else
  LeaveCriticalSection(&v->lock);
	DeleteCriticalSection(&v->lock);
#endif
}

void _vector_delete(VECTOR *v, unsigned i){
	if(i < v->flags[VECTOR_SIZE_FLAG]){
  	return;
  }
  if(v->flags[VECTOR_SIZE_FLAG] > i + 1){
    memmove(
      v->data + (i + 1) * v->flags[VECTOR_ITEM_WIDTH_FLAG],
      v->data + i * v->flags[VECTOR_ITEM_WIDTH_FLAG],
      (v->flags[VECTOR_SIZE_FLAG] - i - 1) * v->flags[VECTOR_ITEM_WIDTH_FLAG]
    );
  }
  v->flags[VECTOR_SIZE_FLAG]--;
}

void vector_delete(VECTOR *v, unsigned i){
  vector_connect(v);
  lock_vector(v);
  _vector_delete(v, i);
  unlock_vector(v);
  vector_disconnect(v);
}

void vector_add(VECTOR *v, void* item){
  vector_connect(v);
  lock_vector(v);
  _vector_add(v, item);
  unlock_vector(v);
  vector_disconnect(v);
}

int vector_bsearch(VECTOR *v, void* key, void* buf, int (__cdecl *replace)(void*, void*),
void* new_item, int *replaced, int add){
	char *res = NULL;
  int result;
  vector_connect(v);
  lock_vector(v);
  if(replaced != NULL){
  	*replaced = 0;
  }
  if(v->compare != NULL){
  	if(v->flags[VECTOR_SIZE_FLAG] > 0){
		  res = (char*)bsearch(key, v->data, v->flags[VECTOR_SIZE_FLAG], v->flags[VECTOR_ITEM_WIDTH_FLAG], v->compare);
    }
    if(res != NULL){
      if(replace != NULL){
        if(replace(res, new_item) == 0){
				  if(replaced != NULL){
          	*replaced = 1;
          }
        }
      }
      if(buf != NULL){
#if defined(WIN32) || defined(__WIN32__)
	      memcpy(buf, res, v->flags[VECTOR_ITEM_WIDTH_FLAG]);
#else
  	    bcopy(res, buf, v->flags[VECTOR_ITEM_WIDTH_FLAG]);
#endif
			}
      result = 0;
    }
    else {
      result = 1;
      if(add){
        _vector_add(v, key);
	      if(buf != NULL){
#if defined(WIN32) || defined(__WIN32__)
  	    memcpy(buf, key, v->flags[VECTOR_ITEM_WIDTH_FLAG]);
#else
    	  bcopy(key, buf, v->flags[VECTOR_ITEM_WIDTH_FLAG]);
#endif
      	}
      }
    }
  }
  unlock_vector(v);
  vector_disconnect(v);
  return result;
}

void print_item(VECTOR *v, void* name, char *file, int line, void* item){
  vector_connect(v);
  lock_vector(v);
  _print_item(v, name, file, line, item);
  unlock_vector(v);
  vector_disconnect(v);
}

void _print_item(VECTOR *v, void* name, char *file, int line, void* item){
	int i;
	printf("%s, %d: %s: ", file, line, name);
	for(i = 0; i < (int)v->flags[VECTOR_ITEM_WIDTH_FLAG]; i++){
		printf("0x%x ", *((char*)item + i));
	}
	printf("\n");
}

void _vector_add(VECTOR *v, void* item){
  upsize_vector(v);
#if defined(WIN32) || defined(__WIN32__)
  memcpy(v->data + v->flags[VECTOR_SIZE_FLAG] * v->flags[VECTOR_ITEM_WIDTH_FLAG], item, v->flags[VECTOR_ITEM_WIDTH_FLAG]);
#else
  bcopy(item, v->data + v->flags[VECTOR_SIZE_FLAG] * v->flags[VECTOR_ITEM_WIDTH_FLAG], v->flags[VECTOR_ITEM_WIDTH_FLAG]);
#endif

  v->flags[VECTOR_SIZE_FLAG]++;
  if(v->compare != NULL){
  	qsort(v->data, v->flags[VECTOR_SIZE_FLAG], v->flags[VECTOR_ITEM_WIDTH_FLAG], v->compare);
  }
}

void _vector_insert(VECTOR *v, void* item, unsigned i){
  if(i >= v->flags[VECTOR_SIZE_FLAG]){
	  _vector_add(v, item);
  }
  else {
	  upsize_vector(v);
    memmove(
    	v->data + i * v->flags[VECTOR_ITEM_WIDTH_FLAG],
      v->data + (i + 1) * v->flags[VECTOR_ITEM_WIDTH_FLAG],
      (v->flags[VECTOR_SIZE_FLAG] - i) * v->flags[VECTOR_ITEM_WIDTH_FLAG]
    );
	  v->flags[VECTOR_SIZE_FLAG]++;
#if defined(WIN32) || defined(__WIN32__)
  memcpy(v->data + i * v->flags[VECTOR_ITEM_WIDTH_FLAG], item, v->flags[VECTOR_ITEM_WIDTH_FLAG]);
#else
  bcopy(item, v->data + i * v->flags[VECTOR_ITEM_WIDTH_FLAG], v->flags[VECTOR_ITEM_WIDTH_FLAG]);
#endif
  }
}

void vector_insert(VECTOR *v, void* item, unsigned i){
  vector_connect(v);
  lock_vector(v);
  _vector_insert(v, item, i);
  unlock_vector(v);
  vector_disconnect(v);
}

void vector_walk(VECTOR *v, void (__cdecl *func)(void*, unsigned, unsigned, void*), void* func_data){
	int i;
  vector_connect(v);
  lock_vector(v);
  for(i = 0; i < (int)v->flags[VECTOR_SIZE_FLAG]; i++){
  	if(func != NULL){
  		func(v->data + i * v->flags[VECTOR_ITEM_WIDTH_FLAG], i, v->flags[VECTOR_SIZE_FLAG], func_data);
    }
  }
  unlock_vector(v);
  vector_disconnect(v);
}

void vector_connect(VECTOR *v){
}

void vector_disconnect(VECTOR *v){
}

int upsize_vector(VECTOR *v){
  if(v->flags[VECTOR_CAPACITY_FLAG] < (v->flags[VECTOR_SIZE_FLAG] + 1)){
    v->flags[VECTOR_CAPACITY_FLAG] *= 2;
  	v->data = (char*)realloc(v->data, v->flags[VECTOR_ITEM_WIDTH_FLAG] * v->flags[VECTOR_CAPACITY_FLAG]);
    return 0;
  }
  return 1;
}