int main (int argc, char *argv[])
{
struct pe_vars v;
long * msg_buffer;
/*
* Initialize
*/
init_mpi(&v);
check_usage(argc, argv, v.npes, v.me);
print_header(v.me);
if (v.me == 0) printf("Total processes = %d\n",v.npes);
/*
* Allocate Memory
*/
msg_buffer = allocate_memory(v.me, &(v.win) );
memset(msg_buffer, 0, MAX_MSG_SZ * ITERS_LARGE * sizeof(long));
/*
* Time Put Message Rate
*/
benchmark(msg_buffer, v.me, v.pairs, v.nxtpe, v.win);
/*
* Finalize
*/
MPI_Win_unlock_all(v.win);
MPI_Win_free(&v.win);
MPI_Free_mem(msg_buffer);
MPI_Finalize();
return EXIT_SUCCESS;
}
int main(int argc, char * argv[])
{
check_usage(argc, argv);
unsigned int value = atoi(argv[1]);
printf("%d\n", bitcount(value));
return 0;
}
int relabsd_config_parse
(
struct relabsd_config * const conf,
int const argc,
char * const * const argv
)
{
RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "Parsing config & params...");
if (check_usage(argc, argv) < 0)
{
return -1;
}
if (argc == 3)
{
conf->device_name = NULL;
RELABSD_S_DEBUG
(
RELABSD_DEBUG_CONFIG,
"No virtual device name param, will use the real device's."
);
}
else
{
conf->device_name = argv[3];
RELABSD_DEBUG
(
RELABSD_DEBUG_CONFIG,
"Virtual device name param set to '%s'.",
conf->device_name
);
}
conf->input_file = argv[1];
RELABSD_DEBUG
(
RELABSD_DEBUG_CONFIG,
"Using configuration file '%s'.",
conf->input_file
);
init_axes_config(conf);
if (read_config_file(conf, argv[2]) < 0)
{
return -1;
}
return 0;
}
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
/*-- input --*/
const mwSize *dim = mxGetDimensions(prhs[0]);
int is_3D = (dim[1] == 3);
double *d_dims = mxGetPr(prhs[0]);
mexSetTrapFlag(1); /* bail to Matlab prompt on mexCallMATLAB error control MATLAB's response to errors in mexCallMATLAB, 1=>On error, control returns to your MEX-file
/*-- check command arguments --*/
if (check_usage(nlhs, plhs, nrhs, prhs) == 0) //check that
return;
uint dims[3] = { d_dims[0], d_dims[1], (is_3D? d_dims[2] : 1) };
mwSize dims_m[3] = { d_dims[0], d_dims[1], (is_3D? d_dims[2] : 1) };
uint N = mxGetScalar(prhs[1]);
uint label_cnt = mxGetScalar(prhs[2]);
m_R_fn = (mxArray *)prhs[3];
m_B_fn = (mxArray *)prhs[4];
V = mxGetPr(prhs[5]);
/*-- weight calculation call backs --*/
m_label = mxCreateDoubleScalar(-1);
label = mxGetPr(m_label);
MALLOC_SET(mxArray *, m_R_w, label_cnt);
/* compute neighbor weights */
m_e = mxCreateNumericMatrix(3, 1, mxDOUBLE_CLASS, mxREAL);
/*-- graph cut --*/
uint *map = graphchop(dims, N, label_cnt, R_fn, B_fn, V);
/*-- output --*/
plhs[0] = mxCreateNumericArray(3, dims_m, mxUINT32_CLASS, mxREAL);
memcpy(mxGetData(plhs[0]), map, dims[0]*dims[1]*dims[2]*sizeof(*map));
/*-- clean up --*/
for (uint i = 0; i < label_cnt; i++)
mxDestroyArray(m_R_w[i]);
JM_FREE(m_R_w);
mxDestroyArray(m_B_w);
mxDestroyArray(m_label);
mxDestroyArray(m_e);
JM_FREE(map);
}
int
main (int argc, char *argv[])
{
int i;
struct pe_vars v;
union data_types * msg_buffer;
int use_heap;
/*
* Initialize
*/
v = init_openshmem();
check_usage(v.me, v.npes, argc, argv);
for (i = 0; i < _SHMEM_REDUCE_SYNC_SIZE; i += 1) {
psync1[i] = _SHMEM_SYNC_VALUE;
psync2[i] = _SHMEM_SYNC_VALUE;
}
shmem_barrier_all();
print_header(v.me);
/*
* Allocate Memory
*/
use_heap = !strncmp(argv[1], "heap", 10);
msg_buffer = allocate_memory(v.me, use_heap);
memset(msg_buffer, 0, sizeof(union data_types [ITERATIONS]));
/*
* Time Put Message Rate
*/
benchmark(v, msg_buffer);
/*
* Finalize
*/
if (use_heap) {
shfree(msg_buffer);
}
return EXIT_SUCCESS;
}
int main(int argc, char* argv[]) {
long thread_index;
int i;
double start, end;
check_usage(argc);
number_of_threads = atoi(argv[1]);
check_perfect_square(number_of_threads);
pthread_t* thread_handles;
thread_handles = malloc( number_of_threads * sizeof *thread_handles );
Lab1_loadinput( &matrix_a,
&matrix_b,
&matrix_size );
matrix_c = malloc( matrix_size * sizeof *matrix_c);
for(i = 0; i < matrix_size; i++)
matrix_c[i] = malloc( matrix_size * sizeof *matrix_c[i]);
GET_TIME(start);
for(thread_index=0; thread_index < number_of_threads; thread_index++)
pthread_create( &thread_handles[thread_index],
NULL,
threadfunc,
(void*) thread_index );
for(thread_index=0; thread_index < number_of_threads; thread_index++)
pthread_join( thread_handles[thread_index], NULL );
GET_TIME(end);
Lab1_saveoutput( matrix_c, &matrix_size, (end-start) );
for(i = 0; i < matrix_size; i++) {
free(matrix_a[i]); free(matrix_b[i]); free(matrix_c[i]);
}
free(matrix_a); free(matrix_b); free(matrix_c);
free(thread_handles);
exit(EXIT_SUCCESS);
}
int main(int argc, char** argv)
{
/* Local variables */
unsigned char buf[BUF_SIZE];
unsigned short l, l2;
FILE* in;
/* Make sure usage is correct */
check_usage(argc, argv);
/* Open and check log file */
in = open_file(argv[1], "r");
/* Read the next entry size */
fread(&l2, 1, sizeof(unsigned short), in);
l = ntohs(l2);
while (!feof(in)) {
/* Sanity-check the entry size */
if (l == 0) {
fprintf(stderr, "Error: got entry size=0\n");
exit_program(-1);
} else if (l > BUF_SIZE) {
fprintf(stderr,
"Error: got entry size %u > BUF_SIZE=%u\n",
l, BUF_SIZE);
exit_program(-2);
}
/* Read in the entry */
fread(buf, l, sizeof(*buf), in);
printf("Entry size=%d, code=0x%X\n", l, buf[0]);
/* Read the next entry size */
fread(&l2, 1, sizeof(unsigned short), in);
l = ntohs(l2);
}
exit_program(0);
return 0;
}
static int rmmod(int log, int verbose, const char *path, int flags)
{
long ret;
char name[strlen(path) + 1];
filename2modname(name, path);
if ((flags & O_NONBLOCK) && !(flags & O_TRUNC)) {
if (check_usage(log, name) != 0)
return 1;
}
info(log, "rmmod %s, wait=%s%s\n", name,
(flags & O_NONBLOCK) ? "no" : "yes",
(flags & O_TRUNC) ? " force" : "");
ret = delete_module(name, flags);
if (ret != 0)
error(log, "Removing '%s': %s\n", name, strerror(errno));
return ret;
}
int
main (int argc, char *argv[])
{
struct pe_vars v;
long * msg_buffer, * aligned_buffer;
long alignment;
int use_heap;
/*
* Initialize
*/
v = init_openshmem();
check_usage(v.me, v.npes, argc, argv);
print_header(v.me);
if (v.me == 0) printf("Total processes = %d\n",v.npes);
/*
* Allocate Memory
*/
use_heap = !strncmp(argv[1], "heap", 10);
alignment = use_heap ? sysconf(_SC_PAGESIZE) : 4096;
msg_buffer = allocate_memory(v.me, alignment, use_heap);
aligned_buffer = align_memory((unsigned long)msg_buffer, alignment);
memset(aligned_buffer, 0, MAX_MSG_SZ * ITERS_LARGE);
/*
* Time Put Message Rate
*/
benchmark(v, aligned_buffer);
/*
* Finalize
*/
if (use_heap) {
shfree(msg_buffer);
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv) {
check_usage(argc);
const char *inputfn = argv[1];
size_t inputfnlen = strlen(inputfn);
char *outputfn = malloc(inputfnlen + 2 + 1);
if (outputfn == NULL) {
error("Could not allocate space for filename.", NULL);
return 1;
}
strncpy(outputfn, inputfn, inputfnlen);
outputfn[inputfnlen] = '.';
outputfn[inputfnlen + 1] = 'o';
outputfn[inputfnlen + 2] = 0;
FILE *input = open_file(inputfn, "r");
FILE *output = open_file(outputfn, "wb+");
assemble_file(input, output);
fclose(input);
fclose(output);
}
int main(int argc, char *argv[])
{
int ch, err;
struct dnet_node *n = NULL;
struct dnet_config cfg;
char *remote_addr = NULL;
int remote_port = -1;
int remote_family = -1;
char *logfile = default_log;
int daemonize = 0;
FILE *log = NULL;
struct dnet_check_request r, *req, *req2;
struct tm tm;
char *file = NULL;
int group_num = 0, *groups;
char *ns = NULL;
int nsize = 0;
struct dnet_session *s;
memset(&cfg, 0, sizeof(struct dnet_config));
cfg.wait_timeout = INT_MAX;
check_logger.log_level = DNET_LOG_INFO;
cfg.check_timeout = 60;
memset(&tm, 0, sizeof(tm));
memset(&r, 0, sizeof(r));
r.thread_num = 1;
while ((ch = getopt(argc, argv, "b:B:DN:f:n:t:u:U:MRm:w:l:dr:g:h")) != -1) {
switch (ch) {
case 'b':
r.blob_start = atoi(optarg);
break;
case 'B':
r.blob_num = atoi(optarg);
break;
case 'N':
ns = optarg;
nsize = strlen(optarg);
break;
case 'f':
file = optarg;
break;
case 'n':
r.thread_num = atoi(optarg);
if (r.thread_num > 1)
fprintf(stderr, "You are going to run your recovery process with %d threads, "
"this can heavily screw up your system performance.\n", r.thread_num);
break;
case 't':
if (!strptime(optarg, "%F %T", &tm)) {
fprintf(stderr, "Invalid timestamp string in -t\n");
check_usage(argv[0]);
return -EINVAL;
}
r.timestamp = mktime(&tm);
break;
case 'u':
if (!strptime(optarg, "%F %T", &tm)) {
fprintf(stderr, "Invalid timestamp string in -u\n");
check_usage(argv[0]);
return -EINVAL;
}
r.updatestamp_start = mktime(&tm);
break;
case 'U':
if (!strptime(optarg, "%F %T", &tm)) {
fprintf(stderr, "Invalid timestamp string in -U\n");
check_usage(argv[0]);
return -EINVAL;
}
r.updatestamp_stop = mktime(&tm);
break;
case 'D':
r.flags |= DNET_CHECK_DRY_RUN;
break;
case 'M':
r.flags |= DNET_CHECK_MERGE;
break;
// case 'F':
// r.flags |= DNET_CHECK_FULL;
// break;
case 'R':
r.flags |= DNET_CHECK_DELETE;
break;
case 'm':
check_logger.log_level = strtoul(optarg, NULL, 0);
break;
case 'w':
cfg.check_timeout = cfg.wait_timeout = atoi(optarg);
break;
case 'l':
logfile = optarg;
break;
case 'd':
daemonize = 1;
break;
case 'r':
err = dnet_parse_addr(optarg, &remote_port, &remote_family);
if (err)
return err;
remote_addr = optarg;
break;
case 'g':
group_num = dnet_parse_groups(optarg, &groups);
if (group_num <= 0)
return -1;
break;
case 'h':
default:
check_usage(argv[0]);
return -1;
}
}
if (!remote_addr) {
fprintf(stderr, "No remote node specified to route requests.\n");
return -ENOENT;
}
log = fopen(logfile, "a");
if (!log) {
err = -errno;
fprintf(stderr, "Failed to open log file %s: %s.\n", logfile, strerror(errno));
return err;
}
if (daemonize) {
if (logfile == default_log) {
fprintf(stderr, "You should specify log file for daemon mode\n");
} else {
dnet_background();
}
}
check_logger.log_private = log;
check_logger.log = dnet_common_log;
cfg.log = &check_logger;
n = dnet_node_create(&cfg);
if (!n)
return -1;
err = dnet_add_state(n, remote_addr, remote_port, remote_family, DNET_CFG_NO_ROUTE_LIST);
if (err)
return err;
s = dnet_session_create(n);
if (!s)
return -ENOMEM;
err = dnet_session_set_ns(s, ns, nsize);
if (err)
return err;
req = &r;
if (file) {
req = dnet_check_gen_request(s, &r, file);
if (!req)
return -EINVAL;
}
if (group_num > 0) {
req2 = malloc(sizeof(struct dnet_check_request) + req->obj_num * sizeof(struct dnet_id) + group_num * sizeof(int));
if (!req2)
return -ENOMEM;
memcpy(req2, req, sizeof(struct dnet_check_request) + req->obj_num * sizeof(struct dnet_id));
memcpy((char *)req2 + sizeof(struct dnet_check_request) + req->obj_num * sizeof(struct dnet_id), groups,
group_num * sizeof(int));
req2->group_num = group_num;
req = req2;
}
return dnet_request_check(s, req);
}
int main(int argc, char** argv)
{
/* Local variables */
struct sockaddr_nl proc_addr, kern_addr; // addrs for recv, send, bind
struct cn_msg *cmsg;
char buf[5000000];
int ret;
unsigned short l, l2;
int count = 0;
/* Make sure usage is correct */
check_usage(argc, argv);
/* Open and check log file */
out = open_file(argv[1], "w");
/* Setup the socket */
sock_fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR);
if (sock_fd == -1)
exit_program_err(-1, "socket");
/* Initialize the address structs */
memset(&proc_addr, 0, sizeof(struct sockaddr_nl));
proc_addr.nl_family = AF_NETLINK;
proc_addr.nl_pid = getpid(); // this process' PID
proc_addr.nl_groups = CN_IDX_IWLAGN;
memset(&kern_addr, 0, sizeof(struct sockaddr_nl));
kern_addr.nl_family = AF_NETLINK;
kern_addr.nl_pid = 0; // kernel
kern_addr.nl_groups = CN_IDX_IWLAGN;
/* Now bind the socket */
if (bind(sock_fd, (struct sockaddr *)&proc_addr, sizeof(struct sockaddr_nl)) == -1)
exit_program_err(-1, "bind");
/* And subscribe to netlink group */
{
int on = proc_addr.nl_groups;
ret = setsockopt(sock_fd, 270, NETLINK_ADD_MEMBERSHIP, &on, sizeof(on));
if (ret)
exit_program_err(-1, "setsockopt");
}
/* Set up the "caught_signal" function as this program's sig handler */
signal(SIGINT, caught_signal);
/* Poll socket forever waiting for a message */
while (1)
{
/* Receive from socket with infinite timeout */
ret = recv(sock_fd, buf, sizeof(buf), 0);
if (ret == -1)
exit_program_err(-1, "recv");
/* Pull out the message portion and print some stats */
cmsg = NLMSG_DATA(buf);
if (count % SLOW_MSG_CNT == 0)
{
// printf("received %d bytes: id: %d val: %d seq: %d clen: %d\n", cmsg->len, cmsg->id.idx, cmsg->id.val, cmsg->seq, cmsg->len);
}
/* Log the data to file */
l = (unsigned short) cmsg->len;
l2 = htons(l);
fwrite(&l2, 1, sizeof(unsigned short), out);
ret = fwrite(cmsg->data, 1, l, out);
fflush(out);
/*
if (count % SLOW_MSG_CNT == 0)
{
printf("wrote %d bytes [msgcnt=%u]\n", ret, count);
}
*/
++count;
if (ret != l)
exit_program_err(1, "fwrite");
}
exit_program(0);
return 0;
}
int main(int arg, char *argv[])
{
int i, j;
int len, daemon;
struct in_addr ad;
char *tmpstr, *tmp, *os, c[5];
char token[50], tty[20], cout[20], major[20], del[50];
FILE *f, *ft;
if (check_usage(arg, argv) != 0)
{
return 0;
}
system("clear");
printf("\nDelete Server ...\n");
idx = 0;
daemon = 0;
tmpstr = (char *)malloc(1024);
len = 1024;
tmp = (char *)malloc(20);
if (arg == 2)
{
sprintf(del, "%s", argv[1]);
sprintf(tmpstr, "%s/npreal2d.cf", DRIVERPATH);
f = fopen (tmpstr, "r");
if (f == NULL)
{
printf("file open error\n");
free(tmpstr);
free(tmp);
return(0);
}
/* search the del server */
for (;;)
{
if (getline (&tmpstr, &len, f) < 0)
{
break;
}
if (strstr(tmpstr, "#") != NULL)
{
continue;
}
memset(major, '\0', 20);
sscanf(tmpstr, "%s", major);
if (strstr(major, "ttymajor") != NULL ||
strstr(major, "calloutmajor") != NULL )
{
continue;
}
sscanf(tmpstr, "%s%s", token, token);
if (strcmp(token, del) == 0)
{
idx = 1;
break;
}
}
fclose (f);
if (idx == 0)
{
printf("The speicified ip is not installed.\n\n");
free(tmpstr);
free(tmp);
return 0;
}
}
else
{
memset(svrList, 0x0, 256*50);
memset(total, 0x0, 256*sizeof(int));
sprintf(tmpstr, "%s/mxcfmat", DRIVERPATH);
system(tmpstr);
sprintf(tmpstr, "%s/npreal2d.cf", DRIVERPATH);
f = fopen (tmpstr, "r");
if (f == NULL)
{
printf("file open error\n");
free(tmpstr);
free(tmp);
return(0);
}
/* print the list of installed server */
for (;;)
{
if (getline (&tmpstr, &len, f) < 0)
{
break;
}
if (strstr(tmpstr, "#") != NULL)
{
continue;
}
memset(major, '\0', 20);
sscanf(tmpstr, "%s", major);
if (strstr(major, "ttymajor") != NULL ||
strstr(major, "calloutmajor") != NULL )
{
continue;
}
sscanf(tmpstr, "%s%s", token, token);
for (i=0; i<idx; i++)
{
if (!strcmp(svrList[i],token))
{
total[i]++;
break;
}
}
if (i == idx)
{
strcpy(svrList[idx], token);
total[idx]++;
idx++;
}
}
fclose (f);
if (idx == 0)
{
printf("No NPort server is installed.\n\n");
free(tmpstr);
free(tmp);
return 0;
}
printf("\n[Index]\t%-40s\t[Port(s)]\n", "[Server IP]");
for (i=0; i<idx; i++)
{
// ad.s_addr = svrList[i];
printf(" (%d)\t%-40s\t %d\n", i+1, svrList[i], total[i]);
}
printf(" (q)\tExit\n");
printf("\nSelect: ");
scanf("%s", c);
if (atoi(c)<=0 || atoi(c)>idx)
{
printf("Please run mxdelsvr again!!\n\n");
free(tmpstr);
free(tmp);
return 0;
}
memset(tmp, '\0', 20);
// GetIP(svrList[atoi(c)-1], tmp);
strcpy(del, svrList[atoi(c)-1]);
}
sprintf(tmpstr, "%s/npreal2d.cf", DRIVERPATH);
f = fopen (tmpstr, "r");
if (f == NULL)
{
printf("file open error\n");
free(tmpstr);
free(tmp);
return(0);
}
ft = fopen ("/tmp/nprtmp_cf", "w");
if (ft == NULL)
{
printf("file open error\n");
free(tmpstr);
free(tmp);
return(0);
}
/* delete all device file configured in npreal2d.cf */
memset(tmpstr, '\0', 1024);
sprintf(tmpstr, "awk '$0 !~ /#/' %s/npreal2d.cf |", DRIVERPATH);
sprintf(tmpstr, "%s awk '$7 != \"\" ' |", tmpstr);
sprintf(tmpstr, "%s awk '$8 != \"\" ' |", tmpstr);
sprintf(tmpstr, "%s awk '{system(\"%s/mxrmnod \"$7); system(\"%s/mxrmnod \"$8)}'", tmpstr, DRIVERPATH, DRIVERPATH);
system(tmpstr);
/* Delete the server selected by user, */
/* and remove the relevant device files */
for (;;)
{
if (getline (&tmpstr, &len, f) < 0)
{
break;
}
if (strstr(tmpstr, "#") != NULL)
{
fputs (tmpstr, ft);
continue;
}
memset(major, '\0', 20);
sscanf(tmpstr, "%s", major);
if (strstr(major, "ttymajor") != NULL ||
strstr(major, "calloutmajor") != NULL )
{
fputs (tmpstr, ft);
continue;
}
sscanf(tmpstr, "%s%s", token, token);
if (strcmp(token, del) != 0)
{
fputs (tmpstr, ft);
/* daemon is a flag which is used to delete the */
/* daemon start string in /etc/rc.d/rc.local */
daemon = 1;
}
}
fclose(ft);
fclose (f);
os = "linux";
f = fopen ("/etc/redhat-release", "r");
if (f != NULL)
{
fclose(f);
os = "linux";
}
else
{
f = fopen ("/etc/SuSE-release", "r");
if (f != NULL)
{
fclose(f);
os = "SuSE";
}
else
{
f = fopen ("/etc/debian_version", "r");
if (f != NULL)
{
os = "debian";
} /* else {
printf("Your Operating System is NOT supported.\n\n");
free(tmpstr);
free(tmp);
return -1;
} */
}
}
if (!daemon)
{
if (os == "linux")
{
system("grep -v mxloadsvr /etc/rc.d/rc.local > /tmp/nprtmp_rclocal");
system("cp -f /tmp/nprtmp_rclocal /etc/rc.d/rc.local > /dev/null 2>&1");
system("rm -f /tmp/nprtmp_rclocal");
}
else if (os == "debian")
{
system("grep -v mxloadsvr /etc/init.d/npreals > /tmp/nprtmp_rclocal");
system("cp -f /tmp/nprtmp_rclocal /etc/init.d/npreals > /dev/null 2>&1");
system("rm -f /tmp/nprtmp_rclocal");
system("update-rc.d npreals defaults 90");
}
else if (os == "SuSE")
{
system("grep -v mxloadsvr /etc/rc.d/boot.local > /tmp/nprtmp_rclocal");
system("cp -f /tmp/nprtmp_rclocal /etc/rc.d/boot.local > /dev/null 2>&1");
system("rm -f /tmp/nprtmp_rclocal");
}
}
sprintf(tmpstr, "cp -f /tmp/nprtmp_cf %s/npreal2d.cf", DRIVERPATH);
system(tmpstr);
system("rm -f /tmp/nprtmp_cf");
printf("Deleted server: %s\n\n", del);
sprintf(tmpstr, "%s/mxloadsvr", DRIVERPATH);
system(tmpstr);
if (os == "linux")
{
system("chmod +x /etc/rc.d/rc.local");
}
else if (os == "debian")
{
system("chmod +x /etc/init.d/npreals");
}
else if (os == "SuSE")
{
system("chmod +x /etc/rc.d/boot.local");
}
free(tmpstr);
free(tmp);
return 0;
}
int main(int argc, char *argv[]) {
check_usage(argc);
init(argv);
run();
return 0;
}
int main(int argc, char** argv)
{
int target = TARGET_UDP_SOCKET;
int input = INPUT_FILE;
int output_mode = OUTPUT_MODE_CLICK;
filter_code = 0xFF;
filter_rate = 0xFFFF;
filter_Nrx = 0xFF;
char *csi_node = "0.0.0.0";
char *tx_node = "0.0.0.1";
int debug_level = 0;
if ( (argc < 5) || ((argc > 1) && (strcmp(argv[1], "help") == 0)) ) {
print_help();
exit(0);
}
target = io_type(argv[1][2],TARGET);
input = io_type(argv[1][0],INPUT);
output_mode = format_type(argv[4][0]);
printf("Config: %s (%s -> %s) %s %s %s\n", argv[1], input_types[input], output_types[target],
argv[2], argv[3], format_types[output_mode]);
if ( argc > 5 ) {
csi_node = argv[5];
tx_node = argv[6];
}
if ( argc > 7 ) {
debug_level = atoi(argv[7]);
}
struct cn_msg *cmsg;
unsigned char cmsg_input_buf[BUF_SIZE];
char sendline[3000];
unsigned char buf[BUF_SIZE];
int ret;
int count = 0;
char hostname[1024];
gethostname(hostname, 1024);
uint32_t csi_node_addr = (uint32_t)inet_addr(csi_node);
uint32_t tx_node_addr = (uint32_t)inet_addr(tx_node);
unsigned short l, l2;
/* Make sure usage is correct */
check_usage(argc, argv);
/* Set up the "caught_signal" function as this program's sig handler */
signal(SIGINT, caught_signal);
/* Prepare Input */
switch ( input ) {
case INPUT_SOCKET:
netlink_sock_fd = open_iwl_netlink_socket();
break;
case INPUT_FILE:
netlink_sock_fd = open_file(argv[3], "r");
break;
}
/* Prepare Output */
switch ( target ) {
case TARGET_TCP_SOCKET:
out_fd = open_tcp_socket(argv[2], 32000);
break;
case TARGET_UDP_SOCKET:
out_fd = open_udp_socket(argv[2], 32000);
break;
case TARGET_FILE:
out_fd = open_file(argv[2], "w");
break;
case TARGET_STDOUT:
out_fd = 1;
break;
}
/* Poll socket forever waiting for a message */
u_char *buf_p;
int len_p, len_sendline;
while (1) {
/* Receive from socket with infinite timeout */
//ret = recv(sock_fd, buf, sizeof(buf), 0);
/* Read the next entry size */
if (DEBUG_LEVEL_DEV) {
printf("\n----- Next Data -----\n\n");
}
switch (input) {
case INPUT_FILE:
/* Read the next entry size */
ret = read(netlink_sock_fd, &l2, 1 * sizeof(unsigned short));
if ( ret != 0 ) {
l = ntohs(l2);
/* Sanity-check the entry size */
if (l == 0) {
fprintf(stderr, "Error: got entry size=0\n");
exit_program(-1);
} else if (l > BUF_SIZE) {
fprintf(stderr, "Error: got entry size %u > BUF_SIZE=%u\n", l, BUF_SIZE);
exit_program(-2);
}
/* Read in the entry */
read(netlink_sock_fd, buf, l * sizeof(*buf));
cmsg = (struct cn_msg*)&cmsg_input_buf[0];
cmsg->id.idx = 0;
cmsg->id.val = 0;
cmsg->seq = 0;
cmsg->ack = 0;
cmsg->len = l;
cmsg->flags = 0;
memcpy(cmsg->data,buf,l);
}
if ( ret == 0 ) ret = -1;
break;
case INPUT_SOCKET:
ret = iwl_netlink_recv(netlink_sock_fd, &buf_p, &len_p, &cmsg);
break;
}
if (ret == -1) exit_program_err(-1, "recv");
if (cmsg == NULL) {
printf("cmsg == NULL\n");
continue;
}
struct iwl5000_bfee_notif *bfee = NULL;
bfee = (struct iwl5000_bfee_notif *)&(cmsg->data[1]);
/* Filter */
if ( (filter_code != 0xFF) && (cmsg->data[0] != filter_code) ) continue;
if ( (filter_rate != 0xFFFF) && (bfee->fake_rate_n_flags != filter_rate) ) continue;
if ( (filter_Nrx != 0xFF) && (bfee->Nrx != filter_Nrx) ) continue;
if (DEBUG_LEVEL_DEV) printf("Entry size=%d, code=0x%X\n", cmsg->len, cmsg->data[0]);
/* Evaluation */
double eff_snrs[MAX_NUM_RATES][4];
if ( cmsg->data[0] == IWL_CONN_BFEE_NOTIF /*0xBB*/) { /* Beamforming packet */
calc_eff_snrs(bfee, eff_snrs);
struct timeval timeVal;
gettimeofday (&timeVal, NULL);
if (DEBUG_LEVEL_INFO) printf("Rcvd pkt at <%ld.%06ld>\n", (long int)(timeVal.tv_sec), (long int)(timeVal.tv_usec));
if (DEBUG_LEVEL_DEV) {
/* Beamforming packet */
printf("\nBeamforming: rate=0x%x\n", bfee->fake_rate_n_flags);
/* Pull out the message portion and print some stats */
if (count % SLOW_MSG_CNT == 0)
printf("Received %d bytes: id: %d val: %d seq: %d clen: %d\n", cmsg->len, cmsg->id.idx, cmsg->id.val, cmsg->seq, cmsg->len);
printf("\n--- Effektive SNR ---\n\n");
int i;
for ( i = 0; i < MAX_NUM_RATES; i++) {
printf("%d: %f %f %f %f\n", i, db(eff_snrs[i][0]), db(eff_snrs[i][1]), db(eff_snrs[i][2]), db(eff_snrs[i][3]));
}
printf("\n---------------------\n\n");
}
}
/* Log the data remote */
/* Puffer mit Text füllen */
switch (output_mode) {
case OUTPUT_MODE_FORMAT:
sprintf(sendline, "%s, Received %d bytes: id: %d val: %d seq: %d clen: %d\n", hostname, cmsg->len, cmsg->id.idx,
cmsg->id.val, cmsg->seq, cmsg->len);
len_sendline = strlen(sendline);
break;
case OUTPUT_MODE_BFEE:
if ( bfee != NULL) {
calc_eff_snrs_tostr(bfee, eff_snrs, sendline, hostname);
} else {
sprintf(sendline, "bfee == NULL\n");
}
if (DEBUG_LEVEL_DEV) printf("To tx:\n%s\n", sendline);
break;
case OUTPUT_MODE_CLICK:
len_sendline = click_output(sendline, bfee, cmsg, eff_snrs, csi_node_addr, tx_node_addr);
break;
default:
/* Log the data to file */
l = (unsigned short) cmsg->len;
l2 = htons(l);
memcpy(sendline, &l2, 1 * sizeof(unsigned short));
len_sendline = 1 * sizeof(unsigned short);
memcpy(&(sendline[len_sendline]), cmsg->data, 1 * l);
len_sendline += 1 * l;
if ((count % 100 == 0) && (DEBUG_LEVEL_DEV)) printf("wrote %d bytes [msgcnt=%u]\n", len_sendline, count);
}
switch ( target ) {
case TARGET_FILE:
case TARGET_TCP_SOCKET:
ret = write(out_fd, sendline, len_sendline);
break;
case TARGET_UDP_SOCKET:
sendto(out_fd, sendline, len_sendline, 0, (struct sockaddr *)&servaddr, sizeof(servaddr));
break;
case TARGET_STDOUT:
dprintf(out_fd,"%s",sendline);
break;
}
++count;
}
exit_program(0);
return 0;
}
