static pid_t fork_with_pipes(int pipefd_in[2], int pipefd_out[2])
{
pid_t child_pid;
if (pipe(pipefd_in) < 0) {
LOG_ERROR(nfqueue, "%s", errno_error(errno));
return -1;
}
if (pipefd_out) {
if (pipe(pipefd_out) < 0) {
LOG_ERROR(nfqueue, "%s", errno_error(errno));
close(pipefd_in[0]);
close(pipefd_in[1]);
return -1;
}
}
child_pid = fork();
if (child_pid < 0) {
LOG_ERROR(nfqueue, "%s", errno_error(errno));
close(pipefd_in[0]);
close(pipefd_in[1]);
if (pipefd_out) {
close(pipefd_out[0]);
close(pipefd_out[1]);
}
return -1;
}
return child_pid;
}
static int open_send_socket(bool mark)
{
int fd;
int one = 1;
fd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
if (fd < 0) {
messagef(HAKA_LOG_ERROR, MODULE_NAME, L"cannot open send socket: %s", errno_error(errno));
return -1;
}
if (setsockopt(fd, IPPROTO_IP, IP_HDRINCL, &one, sizeof(one)) < 0) {
messagef(HAKA_LOG_ERROR, MODULE_NAME, L"cannot setup send socket: %s", errno_error(errno));
return -1;
}
if (mark) {
one = 0xffff;
if (setsockopt(fd, SOL_SOCKET, SO_MARK, &one, sizeof(one)) < 0) {
messagef(HAKA_LOG_ERROR, MODULE_NAME, L"cannot setup send socket: %s", errno_error(errno));
return -1;
}
}
return fd;
}
bool mutex_init(mutex_t *mutex, bool recursive)
{
int err;
pthread_mutexattr_t attr;
err = pthread_mutexattr_init(&attr);
if (err) {
error("mutex error: %s", errno_error(err));
return false;
}
if (recursive)
err = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
else
err = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
if (err) {
error("mutex error: %s", errno_error(err));
return false;
}
err = pthread_mutex_init(mutex, &attr);
pthread_mutexattr_destroy(&attr);
if (err) {
error("mutex error: %s", errno_error(err));
return false;
}
return true;
}
static pid_t fork_with_pipes(int pipefd_in[2], int pipefd_out[2])
{
pid_t child_pid;
if (pipe(pipefd_in) < 0) {
messagef(HAKA_LOG_ERROR, MODULE_NAME, "%s", errno_error(errno));
return -1;
}
if (pipefd_out) {
if (pipe(pipefd_out) < 0) {
messagef(HAKA_LOG_ERROR, MODULE_NAME, "%s", errno_error(errno));
close(pipefd_in[0]);
close(pipefd_in[1]);
return -1;
}
}
child_pid = fork();
if (child_pid < 0) {
messagef(HAKA_LOG_ERROR, MODULE_NAME, "%s", errno_error(errno));
close(pipefd_in[0]);
close(pipefd_in[1]);
if (pipefd_out) {
close(pipefd_out[0]);
close(pipefd_out[1]);
}
return -1;
}
return child_pid;
}
status_t get_link_status(void) {
struct stat sb;
status_t status = STATUS_NONE, newstatus;
int i;
if (stat(NEWPATH, &sb) == -1) {
if (errno != ENOENT)
errno_error("Unable to stat %s", NEWPATH);
if (mkdir(NEWPATH, 0755) == -1)
errno_error("Unable to mkdir %s", NEWPATH);
info("Directory %s created", NEWPATH);
} else if (!S_ISDIR(sb.st_mode))
error("%s exists but is not a directory", NEWPATH);
for (i = 0; i < (int)(sizeof(filenames)/sizeof(filenames[0])); i++) {
char srcpath[PATH_MAX], dstpath[PATH_MAX], linkdst[PATH_MAX];
ssize_t ret;
safe_snprintf(srcpath, sizeof(srcpath), "%s%s", NEWPATH, filenames[i]);
safe_snprintf(dstpath, sizeof(dstpath), "%s%s", OLDPATH, filenames[i]);
if ((ret = safe_readlink(srcpath, linkdst, sizeof(linkdst))) == -1) {
if (errno == ENOENT) {
if (status != STATUS_NONE) {
warn("Inconistent state in %s", NEWPATH);
}
return STATUS_UNKNOWN;
} else
error("Unable to readlink %s", srcpath);
}
newstatus = (strcmp(linkdst, dstpath) == 0) ? STATUS_ENABLED :
(strcmp(linkdst, DEVNULL) == 0) ? STATUS_DISABLED :
STATUS_UNKNOWN;
if (newstatus == STATUS_UNKNOWN)
warn("%s points to unknown file %s", srcpath, linkdst);
if (status != STATUS_NONE && status != newstatus) {
warn("Inconistent state in %s", NEWPATH);
return STATUS_UNKNOWN;
}
status = newstatus;
}
return (status == STATUS_NONE) ? STATUS_UNKNOWN : status;
}
size_t file::write(const void* buffer, size_t n)
{
ssize_t count = ::write(_M_fd, buffer, n);
if(count == -1) throw errno_error();
return count;
}
storage::offset size(const std::string& name)
{
struct stat x;
if(::stat(name.data(), &x)) throw errno_error();
return x.st_size;
}
offset file::seek(storage::offset offset, storage::origin origin)
{
storage::offset n = ::lseek(_M_fd, offset, static_cast<int>(origin));
if(n == -1) throw errno_error();
return n;
}
int file::control(int request, void* buffer)
{
int val = ::ioctl(_M_fd, request, buffer);
if(val == -1) throw errno_error();
return val;
}
static void report_error(struct luadebug_remote_user *user, int err)
{
if (!user->error) {
messagef(HAKA_LOG_ERROR, MODULE, L"remote communication error: %s", errno_error(err));
user->error = true;
}
}
static int packet_do_receive(struct packet_module_state *state, struct packet **pkt)
{
const int rv = recv(state->fd, state->receive_buffer,
sizeof(state->receive_buffer), 0);
if (rv < 0) {
messagef(HAKA_LOG_ERROR, MODULE_NAME, L"packet reception failed, %s", errno_error(errno));
return 0;
}
if (nfq_handle_packet(state->handle, state->receive_buffer, rv) == 0) {
if (state->current_packet) {
state->current_packet->state = state;
*pkt = (struct packet*)state->current_packet;
if (pcap) {
dump_pcap(&pcap->in, state->current_packet);
}
state->current_packet = NULL;
return 0;
}
else {
return state->error;
}
}
else {
message(HAKA_LOG_ERROR, MODULE_NAME, L"packet processing failed");
return 0;
}
}
size_t file::read(void* buffer, size_t max, bool wait)
{
ssize_t count = 0;
if(wait || can_read(std::chrono::seconds(0))) count = ::read(_M_fd, buffer, max);
if(count == -1) throw errno_error();
return count;
}
bool thread_cancel(thread_t thread)
{
const int err = pthread_cancel(thread);
if (err) {
error("thread cancel error: %s", errno_error(err));
return false;
}
return true;
}
bool thread_join(thread_t thread, void **ret)
{
const int err = pthread_join(thread, ret);
if (err) {
error("thread join error: %s", errno_error(err));
return false;
}
return true;
}
bool thread_create(thread_t *thread, void *(*main)(void*), void *param)
{
const int err = pthread_create(thread, NULL, main, param);
if (err) {
error("thread creation error: %s", errno_error(err));
return false;
}
return true;
}
bool local_storage_set(local_storage_t *key, const void *value)
{
const int err = pthread_setspecific(*key, value);
if (err) {
error("local storage error: %s", errno_error(err));
return false;
}
return true;
}
bool mutex_unlock(mutex_t *mutex)
{
const int err = pthread_mutex_unlock(mutex);
if (err) {
error("mutex error: %s", errno_error(err));
return false;
}
return true;
}
bool barrier_destroy(barrier_t *barrier)
{
const int err = pthread_barrier_destroy(barrier);
if (err) {
error("barrier error: %s", errno_error(err));
return false;
}
return true;
}
bool semaphore_post(semaphore_t *semaphore)
{
const int err = sem_post(semaphore);
if (err) {
error("semaphore error: %s", errno_error(err));
return false;
}
return true;
}
bool semaphore_init(semaphore_t *semaphore, uint32 initial)
{
const int err = sem_init(semaphore, 0, initial);
if (err) {
error("semaphore error: %s", errno_error(err));
return false;
}
return true;
}
bool rwlock_unlock(rwlock_t *rwlock)
{
const int err = pthread_rwlock_unlock(rwlock);
if (err) {
error("rwlock error: %s", errno_error(err));
return false;
}
return true;
}
bool spinlock_unlock(spinlock_t *lock)
{
const int err = pthread_spin_unlock(lock);
if (err) {
error("spinlock error: %s", errno_error(err));
return false;
}
return true;
}
bool spinlock_init(spinlock_t *lock)
{
const int err = pthread_spin_init(lock, PTHREAD_PROCESS_PRIVATE);
if (err) {
error("spinlock error: %s", errno_error(err));
return false;
}
return true;
}
bool thread_signal(thread_t thread, int sig)
{
const int err = pthread_kill(thread, sig);
if (err) {
error("thread sigmask error: %s", errno_error(err));
return false;
}
return true;
}
bool thread_sigmask(int how, sigset_t *set, sigset_t *oldset)
{
const int err = pthread_sigmask(how, set, oldset);
if (err) {
error("thread sigmask error: %s", errno_error(err));
return false;
}
return true;
}
bool barrier_wait(barrier_t *barrier)
{
const int err = pthread_barrier_wait(barrier);
if (err && err != PTHREAD_BARRIER_SERIAL_THREAD) {
error("barrier error: %s", errno_error(err));
return false;
}
return true;
}
bool local_storage_init(local_storage_t *key, void (*destructor)(void *))
{
const int err = pthread_key_create(key, destructor);
if (err) {
error("local storage error: %s", errno_error(err));
return false;
}
return true;
}
bool local_storage_destroy(local_storage_t *key)
{
const int err = pthread_key_delete(*key);
if (err) {
error("local storage error: %s", errno_error(err));
return false;
}
return true;
}
bool barrier_init(barrier_t *barrier, uint32 count)
{
const int err = pthread_barrier_init(barrier, NULL, count);
if (err) {
error("barrier error: %s", errno_error(err));
return false;
}
return true;
}
bool thread_setcancelstate(bool enable)
{
const int err = pthread_setcancelstate(enable ? PTHREAD_CANCEL_ENABLE : PTHREAD_CANCEL_DISABLE, NULL);
if (err) {
error("thread set cancel state error: %s", errno_error(err));
return false;
}
return true;
}