int main(int argc, char *argv[]) {
if (argc < 2) {
_print_usage(argv[0]);
exit(0);
}
/* The file we're going to load in: */
const char *file_path = argv[1];
/* Where we're going to store our loaded buffer: */
char *buf = NULL;
size_t buf_siz = 0;
buf = lair_load_file(file_path, &buf_siz);
if (buf == NULL) {
error_and_die(ERR_RUNTIME, "Could not load file.");
return 1;
}
int rc = lair_execute(buf, buf_siz);
if (rc != 0) {
error_and_die(ERR_RUNTIME, "Could not execute.");
return 1;
}
lair_unload_file(buf, buf_siz);
return 0;
}
CKMotionLocal::CKMotionLocal()
{
int fd = shm_open(memname, O_CREAT | O_EXCL | O_RDWR, 0666);
if (fd == -1){
if(errno == EEXIST){
fd = shm_open(memname, O_RDWR, 0666);
}
if (fd == -1){
error_and_die("shm_open");
}
} else {
if (ftruncate(fd, region_size) != 0){
error_and_die("ftruncate");
} else {
//log_info("Success");
}
}
ptr = mmap(0, region_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (ptr == MAP_FAILED) {
error_and_die("mmap");
}
close(fd);
sharePtr = (u_int32_t *) ptr;
(*sharePtr)++;
}
void
create_directory(const char* path) {
size_t length = strlen(path) + 2; //extra '/' and '\0'
char path_copy[length];
strcpy(path_copy, path);
path_copy[length-2] = '/';
char* sub_path = path_copy;
while ((sub_path = strchr(sub_path, '/')) != NULL) {
*sub_path = '\0';
struct stat stat_buf;
if (stat(path_copy, &stat_buf) != 0) {
if (errno != ENOENT) { //we're just testing to see if the directory exists
perror_and_die("stat() failed");
}
} else {
if (!S_ISDIR(stat_buf.st_mode)) {
error_and_die("create_directory: can't mkdir on *file* %s", path_copy);
}
}
mkdir(path_copy, 0700);
*(sub_path++) = '/';
}
}
int main(int argc, char *argv[]) {
int r;
const char *memname = "sample";
const size_t region_size = sysconf(_SC_PAGE_SIZE);
int fd = shm_open(memname, O_CREAT | O_TRUNC | O_RDWR, 0666);
if (fd == -1)
error_and_die("shm_open");
r = ftruncate(fd, region_size);
if (r != 0)
error_and_die("ftruncate");
void *ptr = mmap(0, region_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (ptr == MAP_FAILED)
error_and_die("mmap");
close(fd);
pid_t pid = fork();
if (pid == 0) {
u_long *d = (u_long *) ptr;
*d = 0xdbeebee;
exit(0);
}
else {
int status;
waitpid(pid, &status, 0);
printf("child wrote %#lx\n", *(u_long *) ptr);
}
r = munmap(ptr, region_size);
if (r != 0)
error_and_die("munmap");
r = shm_unlink(memname);
if (r != 0)
error_and_die("shm_unlink");
return 0;
}
void device_set_flags(const char *ifname, const short flags)
{
int ret, sock;
struct ifreq ifr;
sock = af_socket(AF_INET);
memset(&ifr, 0, sizeof(ifr));
strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
ifr.ifr_flags = flags;
ret = ioctl(sock, SIOCSIFFLAGS, &ifr);
if (ret < 0)
error_and_die(EXIT_FAILURE, "Cannot set NIC flags!\n");
close(sock);
}
int main(int argc, char *argv[], char *envp[]){
int err;
int backlog = 100;
//Thread stuff
pthread_t tid;
pthread_t tid_operator, tid_heartbeat;
// Shared Memory;
int shmid;
key_t key;
int *shm;
//Socket stuff
struct sockaddr_in local_addr;
struct sockaddr_in client_addr;
int socket_fd;
int new_socket;
int option=1;
/* set handler for signal SIGINT */
struct sigaction new_action;
new_action.sa_handler = signal_handler;
sigemptyset (&new_action.sa_mask);
new_action.sa_flags = 0;
sigaction (SIGINT, &new_action, NULL);
//----------------------- Shared memory init --------------------
//We'll name our shared memory segment "1234".
key = 1234;
//Create the segment.
if ((shmid = shmget(key, sizeof(int), IPC_CREAT | 0666)) < 0)
error_and_die("shmget-front server");
//Now we attach the segment to our data space.
if ((shm = shmat(shmid, NULL, 0)) == (int *) -1)
error_and_die("shmat");
//----------------------- launch data-server --------------------
wake_dataserver(envp);
//--------------------------- heartbeat -------------------------
struct pii args;
args.shm = shm;
args.envp = envp;
pthread_create( &tid_heartbeat, NULL, manage_heartbeat, (void *)(&args) );
//----------------------- Socket creation -----------------------
// create socket
if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(-1);
}
local_addr.sin_family = AF_INET;
local_addr.sin_port = htons(FRONT_PORT);
local_addr.sin_addr.s_addr = INADDR_ANY;
//make socket immediatly available after it closes
setsockopt(socket_fd,SOL_SOCKET,(SO_REUSEADDR),(char*)&option,sizeof(option));
// bind socket
err = bind(socket_fd, (struct sockaddr*) &local_addr, sizeof(local_addr));
if(err == -1) {
perror("bind");
exit(-1);
}
// listen
err = listen(socket_fd, backlog);
if(err == -1) {
perror("listen");
exit(-1);
}
//---------------------------------- operator ----------------------------------
pthread_create(&tid_operator, NULL, manage_operator, NULL);
socklen_t client_addr_size = sizeof(client_addr);
int errsv;
while(1){
//----------------------- manage client connections ---------------
new_socket = accept(socket_fd, (struct sockaddr*) &client_addr, &client_addr_size);
errsv = errno;
//if signal is received while in accept, it will return -1 and generate the EINTR error
if(new_socket < 0 && errsv==EINTR) continue;
if(new_socket == 0) {
perror("socket accept");
exit(-1);
}
err = pthread_create(&tid, NULL, manage_client, (void *) new_socket);
if(err!=0) {
perror("pthread_create");
}
}
}
int
main(int argc, char* argv[]) {
enum COPY_STRATEGY strategy = UNKNOWN;
const char* ignore_pattern = NULL;
bool verbose_flag = false;
int result = 0, strategy_set_count = 0;
while ((result = getopt(argc, argv, "ci:lmv")) != -1) {
switch (result) {
case 'c':
strategy_set_count++;
strategy = CONTENTS;
break;
case 'l':
strategy_set_count++;
strategy = LARGEST;
break;
case 'm':
strategy_set_count++;
strategy = MOST_RECENT;
break;
case 'v':
verbose_flag = true;
break;
case 'i':
ignore_pattern = optarg;
break;
case '?':
error_and_die("getopt() failed");
break; //never executes
default:
error_and_die("Unknown option %c", (char) result);
break; //never executes
}
}
if (strategy_set_count > 1) {
error_and_die("can only provide zero or one of options -l, -m, -c");
}
if (strategy == UNKNOWN) {
strategy = MOST_RECENT; //assume -m if none given
}
if (argc-optind < 2) {
error_and_die("Require at least one input and output directory.\n"
"Usage mergedirs [options] indirectory1 [indirectory2 ....] outdirectory");
}
const char* output_dir = argv[argc-1];
argv[argc-1] = NULL; //analysis_stage expects a NULL sentinel'd array of strings
char** file_list = analysis_stage((const char**)(argv+optind), ignore_pattern, strategy);
if (strategy != CONTENTS) { //We don't copy if it's -c
copy_stage((const char**)file_list, output_dir, verbose_flag);
}
//not strictly necessary, but it's nice to have valgrind pat us on the back
for (int i = 0; file_list[i] != NULL; ++i) {
free(file_list[i]);
}
free(file_list);
return 0;
}
