Пример #1
1
void startAccount(int clientSocket, char *commandArg, int *in_session)
{
    if(*in_session >= 0){
        write(clientSocket, "Cannot create account, you're in a session.", 43);
        return;
    }

    sem_t *bankLock = sem_open(BANKLOCK, 0);
    sem_wait(bankLock);

    // find specified account
    int i;
    for(i = 0; i < MAXACCOUNTS; i++)
    {
        if(bank->accounts[i].name[0] == '\0'){ // free account; end of list
            break;
        }

        if(strcmp(bank->accounts[i].name, commandArg) == 0) // found bank
        {
            // wait till account is free to use
            while(bank->accounts[i].in_use){
                write(clientSocket, "Account currently in use, waiting to connect", 44);
                sleep(2); // wait 2 seconds
            }

            // start session
            bank->accounts[i].in_use = 1;
            *in_session = i;
            write(clientSocket, "Connected successfully!", 23);
            break;
        }
    }

    if(i >= MAXACCOUNTS){ // bank not found
        write(clientSocket, "Error: bank with specified account name not found.", 50);
    }

    sem_post(bankLock);

    return;
}
Пример #2
0
/*
 * PosixSemaphoreCreate
 *
 * Attempt to create a new___ named semaphore.
 *
 * If we fail with a failure code other than collision-with-existing-sema,
 * print out an error and abort.  Other types of errors suggest nonrecoverable
 * problems.
 */
static sem_t *
PosixSemaphoreCreate(void)
{
	int			semKey;
	char		semname[64];
	sem_t	   *mySem;

	for (;;)
	{
		semKey = nextSemKey++;

		snprintf(semname, sizeof(semname), "/pgsql-%d", semKey);

		mySem = sem_open(semname, O_CREAT | O_EXCL,
						 (mode_t) IPCProtection, (unsigned) 1);

#ifdef SEM_FAILED
		if (mySem != (sem_t *) SEM_FAILED)
			break;
#else
		if (mySem != (sem_t *) (-1))
			break;
#endif

		/* Loop if error indicates a collision */
		if (errno == EEXIST || errno == EACCES || errno == EINTR)
			continue;

		/*
		 * Else complain and abort
		 */
		elog(FATAL, "sem_open(\"%s\") failed: %m", semname);
	}

	/*
	 * Unlink the semaphore immediately, so it can't be accessed externally.
	 * This also ensures that it will go away if we crash.
	 */
	sem_unlink(semname);

	return mySem;
}
Пример #3
0
int
main(int argc, char *argv[])
{
  int value;
  sem_t *sem;

  if (argc != 2)
    usageErr("%s sem-name\n", argv[0]);

  sem = sem_open(argv[1], 0);
  if (sem == SEM_FAILED)
    errExit("sem_open");

  if (sem_getvalue(sem, &value) == -1)
    errExit("sem_getvalue");

  printf("%d\n", value);

  exit(EXIT_SUCCESS);
}
Пример #4
0
sem_t* sem_open_anon()
{
	static const char* kSemTempNameBase = "semtemp";
	sem_t* sem;
	char sem_name[255];
	
	snprintf(sem_name, 254, "%s%d", kSemTempNameBase, getpid());	
	sem = sem_open(sem_name, O_CREAT|O_EXCL, S_IRWXU, 0);
	
	if (sem == SEM_FAILED) {
		perror("sem_open");
		return NULL;
	}
	
	if (sem_unlink(sem_name) < 0) {
		perror("WARN: sem_unlin");
	}
	
	return sem;
}
Пример #5
0
struct slock *
s_alloc()
{
    struct slock *sp;
    static int    cnt;  /* 引用计数 */

    if ((sp = malloc(sizeof(struct slock))) == NULL)
        return(NULL);
    do {
        snprintf(sp-name, sizeof(sp->name), "/%ld.%d", (long)getpid(), cnt++);
        sp->semp = sem_open(sp->name, O_CREAT | O_EXCL, S_IRWXU, 1);
    } while ((sp->semp == SEM_FAILED) && (errno == EEXIST));
    if (sp->semp == SEM_FAILED) {
        free(sp);
        return(NULL);
    }
    /* 销毁了名字,导致进程不能再次访问它,简化了进程结束时的清理工作 */
    sem_unlink(sp->name);   /* 引用为0时才delete */
    return(sp);
}
Пример #6
0
/**
@details
-# Set the SIGALRM signal handler to the ITimer signal handler routine.
-# Open a unique named semaphore
*/
int Trick::ITimer::init() {

    static struct sigaction sigact;
    std::stringstream sem_name_stream ;

    sigact.sa_handler = (void (*)(int)) it_handler;
    if (sigaction(SIGALRM, &sigact, NULL) < 0) {
        perror("sigaction() failed for SIGALRM");
    }

    // Initialize the itimer semaphore used by SIGALRM handler to
    // wake up the sim_exec_loop from its underrun sleepy time.

    sem_name_stream << "itimersepmaphore_" << getpid() ;
    sem_name = sem_name_stream.str() ;

    semaphore = sem_open(sem_name.c_str(), O_CREAT, S_IRWXU , 0);

    return (0) ;
}
Пример #7
0
int main(int argc, char *argv[]) {
  if (argc != 4) err_quit("Usage: client1 <shmname> <semname> <#loops>");

  int nloops = atoi(argv[3]);

  int fd = shm_open(argv[1], O_RDWR, FILE_MODE);
  struct shmstruct *ptr = mmap(NULL, sizeof(struct shmstruct),
                               PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
  close(fd);

  sem_t *mutex = sem_open(argv[2], 0);

  int pid = getpid();

  for (int i = 0; i < nloops; i++) {
    sem_wait(mutex);
    printf("pid = %d: %d\n", pid, ptr->count++);
    sem_post(mutex);
  }
}
Пример #8
0
int am_agent_instance_init_init(int id) {
    int status = AM_ERROR;
#if defined(_WIN32)
    ic_sem = CreateSemaphoreA(NULL, 1, 1, get_global_name("Global\\"AM_CONFIG_INIT_NAME, id));
    if (ic_sem != NULL) {
        status = AM_SUCCESS;
    }
#elif defined(__APPLE__)
    kern_return_t rv = semaphore_create(mach_task_self(), &ic_sem, SYNC_POLICY_FIFO, 1);
    if (rv == KERN_SUCCESS) {
        status = AM_SUCCESS;
    }
#else
    ic_sem = sem_open(get_global_name(AM_CONFIG_INIT_NAME, id), O_CREAT, 0600, 1);
    if (ic_sem != SEM_FAILED) {
        status = AM_SUCCESS;
    }
#endif
    return status;
}
Пример #9
0
sem_t open_sample_semaphore(int32_t ant, int32_t swing, int32_t dir ) {
    char sem_name[80];
    sem_t *sem = NULL;
    if(dir == TXDIR) {
       sprintf(sem_name,"/semaphore_tx_ant_%d_swing_%d", ant, swing);
    }
    else {
       sprintf(sem_name,"/semaphore_rx_ant_%d_swing_%d", ant, swing);
    }
    
    fprintf(stderr, "usrp_driver opening: %s\n", sem_name);
    sem = sem_open(sem_name, 0);

    if (sem == SEM_FAILED) {
        sem = NULL;
        fprintf(stderr, "Getting a handle to the semaphore failed; errno is %d", errno);
    }

    return *sem;
}
Пример #10
0
int main()
{
	sem_t   *mysemp;
	char semname[50];

	sprintf(semname, "/" FUNCTION "_" TEST "_%d", getpid());

	mysemp = sem_open(semname, O_CREAT, 0777, 1);

	if (( mysemp == SEM_FAILED ) || (mysemp == NULL ))
	{
		puts("TEST FAILED");
		return PTS_FAIL;
	} else {
		puts("TEST PASSED");
		sem_close(mysemp);
		sem_unlink(semname);
		return PTS_PASS;
	}
}
Пример #11
0
int main(int argc, char** argv)
{
	if (2 != argc)
	{
		printf("%s name\n", argv[0]);
		return -1;
	}
	
	int flags = O_CREAT | O_RDWR;
	const char* _name = argv[1];
	sem_t* _newsem = sem_open(_name, flags, 0644, 1);
	if (SEM_FAILED == _newsem)
	{
		perror("sem_open fail");
		return -1;
	}
	
	sem_close(_newsem);
	return 0;
}
Пример #12
0
static sem_t *IM_PosixSemOpen(const SINT8 *pSemName)
{
    sem_t *pSem;

    if (NULL == pSemName)
    {
        IM_SHM_LOG(IM_SHM_LOG_FLAG, IM_SHM_LOG_ERR, "Semaphore name is null!");
        return NULL;
    }
    
    pSem = sem_open(pSemName, 0);
    if (SEM_FAILED == pSem)
    {
        IM_SHM_LOG(IM_SHM_LOG_FLAG, IM_SHM_LOG_ERR, "Open semaphore %s failed. Reason: %s", 
            pSemName, strerror(errno));
        return NULL;
    }
    
    return pSem;
}
Пример #13
0
FskErr FskSemaphoreNew_(FskSemaphore *sem, UInt32 value, FSK_SYNCHRONIZATION_DEBUG_ARGS)
#endif
{
	FskErr err;

	err = FskMemPtrNewClear(sizeof(FskSemaphoreRecord), (FskMemPtr *)sem);
	BAIL_IF_ERR(err);

#if TARGET_OS_MAC
	{
		FskSemaphore s = *sem;
		snprintf(s->name, sizeof(s->name)-1, "/tmp/sem%lx", (unsigned long)s);
		if ((s->hSem = sem_open(s->name, O_CREAT|O_EXCL, 666, value)) == NULL) {
			BAIL(kFskErrOperationFailed);
		}
	}
#else
	if (sem_init(&(*sem)->hSem, 0, value) != 0) {
		BAIL(kFskErrOperationFailed);
	}
#endif

	FskInstrumentedItemNew(*sem, NULL, &gFskSemaphoreTypeInstrumentation);
#if SUPPORT_INSTRUMENTATION && SUPPORT_SYNCHRONIZATION_DEBUG
	if (FskInstrumentedItemHasListeners(*sem)) {
		FskSynchronizationInstrMsgRecord msg;
		msg.file = file;
		msg.line = line;
		msg.function = function;
		FskInstrumentedItemSendMessage(*sem, kFskSynchronizationInstrMsgSemaphoreNew, &msg);
	}
#endif

bail:
	if ((err != kFskErrNone) && (*sem != NULL)) {
		FskMemPtrDispose(*sem);
		*sem = NULL;
	}

	return err;
}
Пример #14
0
int main(void)
{
	char semname[NAME_MAX - 4];
	sem_t *mysemp;
	int val;

	snprintf(semname, sizeof(semname), "/" FUNCTION "_" TEST "_%ld",
		 (long)getpid());

	mysemp = sem_open(semname, O_CREAT, 0777, 1);

	if (mysemp == SEM_FAILED || mysemp == NULL) {
		perror(ERROR_PREFIX "sem_open");
		return PTS_UNRESOLVED;
	}

	/* Lock Semaphore */
	if (sem_trywait(mysemp) == -1) {
		perror(ERROR_PREFIX "trywait");
		return PTS_UNRESOLVED;
	}

	if (sem_getvalue(mysemp, &val) < 0) {
		perror(ERROR_PREFIX "sem_getvalue");
		return PTS_UNRESOLVED;
	}

	/*
	   printf("Current value is: %d\n", val);
	 */

	if (val <= 0) {
		puts("TEST PASSED");
		sem_close(mysemp);
		sem_unlink(semname);
		return PTS_PASS;
	} else {
		puts("TEST FAILED");
		return PTS_FAIL;
	}
}
Пример #15
0
/**
 * Create a new semaphore
 * @return the new condition variable
 */
sem_type Thread_create_sem()
{
	sem_type sem = NULL;
	int rc = 0;

	FUNC_ENTRY;
	#if defined(WIN32) || defined(WIN64)
		sem = CreateEvent(
		        NULL,               // default security attributes
		        FALSE,              // manual-reset event?
		        FALSE,              // initial state is nonsignaled
		        NULL                // object name
		        );
    #elif defined(USE_NAMED_SEMAPHORES)
    	if (named_semaphore_count == 0)
    		memset(named_semaphores, '\0', sizeof(named_semaphores));
    	char* name = &(strrchr(tempnam("/", "MQTT"), '/'))[1]; /* skip first slash of name */
    	if ((sem = sem_open(name, O_CREAT, S_IRWXU, 0)) == SEM_FAILED)
    		rc = -1;
    	else
    	{
    		int i;
    		
    		named_semaphore_count++;
    		for (i = 0; i < MAX_NAMED_SEMAPHORES; ++i)
    		{
    			if (named_semaphores[i].name[0] == '\0')
    			{ 
    				named_semaphores[i].sem = sem;
    				strcpy(named_semaphores[i].name, name);	
    				break;
    			}
    		}
    	}
	#else
		sem = malloc(sizeof(sem_t));
		rc = sem_init(sem, 0, 0);
	#endif
	FUNC_EXIT_RC(rc);
	return sem;
}
Пример #16
0
int main(int argc, char **argv) {
    int fd, nloops;
    sem_t *sem;
    int *ptr;

    if(argc != 4) {
        printf("Usage: %s <semname> <shmname> <#nloops>\n", argv[0]);
        exit(1);
    }
    nloops = atoi(argv[3]);

    /* create semaphore */
    sem = sem_open(argv[1], O_RDWR);
    if(sem == SEM_FAILED) {
        perror("sem_open error");
        exit(1);
    }

    /* create shared memory object */
    fd = shm_open(argv[2], O_RDWR, 0);
    if(fd < 0) {
        perror("shm_open error");
        exit(1);
    }

    ptr = (int *)mmap(NULL, sizeof(int), 
            PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 
    if(ptr == MAP_FAILED) {
        perror("mmap error");
        exit(1);
    }
    close(fd);

    for(int i = 0; i < nloops; ++i) {
        sem_wait(sem);
        printf("pid=%ld, value=%d\n", (long)getpid(), (*ptr)++);
        sem_post(sem);
    } 

    exit(0);
}
Пример #17
0
int main(int argc, char **argv)
{
    sem_t *sem;
    int val;
    int ret = 0;

    if (argc != 2)
    {
        printf("usage: semgetvalue <name>\n");
        return -1;
    }

    sem = sem_open(argv[1], 0);
    assert(SEM_FAILED != sem);

    ret = sem_getvalue(sem, &val);
    assert(-1 != ret);
    printf("value = %d\n", val);

    return 0;
}
Пример #18
0
void* mfilter_init()
{
    //TODO:
	MailFilter * filter = new MailFilter;
	if(filter)
	{
		filter->isJunk = -1;
	}

	tm * ltm;
	time_t tt = time(NULL);
	ltm = localtime(&tt);
	char szFileName[1024];
	sprintf(szFileName, "/var/log/erisemail/MTA-%04d-%02d-%02d.log", 1900 + ltm->tm_year, ltm->tm_mon + 1, ltm->tm_mday);
	
	
	filter->semLog = sem_open("/.erisemail-mta-log.sem", O_CREAT | O_RDWR, 0644, 1);		
	filter->fLog = fopen(szFileName, "ab+");
	
	return (void*)filter;
}
Пример #19
0
int main(int argc,char *argv[])
{
    int n=0;
    sem=sem_open(argv[1],O_CREAT,0644,3);
    sem_getvalue(sem,&val);
    printf("The value have %d\n",val);
    while(n++<5)
    {
     	if(fork()==0)
	{
	    sem_wait(sem);
	    print(getpid());
	    sleep(1);
	    sem_post(sem);
  	    printf("I'm finished,my pid is %d\n",getpid());
   	    return 0;
	}
    }  
    wait();
    return 0;
}
// Client side : get the published semaphore from server
bool JackPosixSemaphore::ConnectInput(const char* name, const char* server_name)
{
    BuildName(name, server_name, fName, sizeof(fName));
    jack_log("JackPosixSemaphore::Connect name = %s", fName);

    // Temporary...
    if (fSemaphore) {
        jack_log("Already connected name = %s", name);
        return true;
    }

    if ((fSemaphore = sem_open(fName, O_CREAT)) == (sem_t*)SEM_FAILED) {
        jack_error("Connect: can't connect named semaphore name = %s err = %s", fName, strerror(errno));
        return false;
    } else {
        int val = 0;
        sem_getvalue(fSemaphore, &val);
        jack_log("JackPosixSemaphore::Connect sem_getvalue %ld", val);
        return true;
    }
}
Пример #21
0
static inline void subprocess_leak(void)
{
	struct sigevent sevt;
	pthread_mutex_t mutex;
	pthread_cond_t cond;
	pthread_t thread;
	sem_t sem, *psem;
	timer_t tm;
	int fd;

	check_pthread(pthread_create(&thread, NULL, empty, NULL));
	check_pthread(pthread_mutex_init(&mutex, NULL));
	check_pthread(pthread_cond_init(&cond, NULL));
	check_unix(sem_init(&sem, 0, 0));
	check_unix(-!(psem = sem_open(SEM_NAME, O_CREAT, 0644, 1)));
	sevt.sigev_notify = SIGEV_THREAD_ID;
	sevt.sigev_signo = SIGALRM;
	sevt.sigev_notify_thread_id = syscall(__NR_gettid);
	check_unix(timer_create(CLOCK_MONOTONIC, &sevt, &tm));
	check_unix(fd = mq_open(MQ_NAME, O_RDWR | O_CREAT, 0644, NULL));
}
Пример #22
0
static void test_sem_init_too_large_inital_value(void)
{
  sem_t  sem;
  sem_t *sem2;
  int    rv;

  errno = 0;
  rv = sem_init( &sem, 0, (unsigned int) SEM_VALUE_MAX + 1 );
  rtems_test_assert( rv == -1 );
  rtems_test_assert( errno == EINVAL );

  errno = 0;
  sem2 = sem_open(
    "sem",
    O_CREAT | O_EXCL,
    0777,
    (unsigned int) SEM_VALUE_MAX + 1
  );
  rtems_test_assert( sem2 == SEM_FAILED );
  rtems_test_assert( errno == EINVAL );
}
Пример #23
0
int
sim_open_sem(char * sem_name, sem_t ** mutex_sync, int max_attempts)
{
	int iter = 0, max_iter = max_attempts;
	if (!max_iter) max_iter = 10;
	while ((*mutex_sync) == SEM_FAILED && iter < max_iter) {
		(*mutex_sync) = sem_open(sem_name, 0, 0755, 0);
		if ((*mutex_sync) == SEM_FAILED && max_iter > 1) {
			int err = errno;
			info("ERROR! Could not open semaphore (%s)-- %s",
					sem_name, strerror(err));
			sleep(1);
		}
		++iter;
	}

	if ((*mutex_sync) == SEM_FAILED)
		return -1;
	else
		return 0;
}
Пример #24
0
int
main(int argc, char **argv)
{
    int    ret = 0;
    sem_t *sem;
   
    CHECK_ARGS(2, "<path>");
   
    sem = sem_open(argv[1], 0);
    if (sem == (sem_t *)SEM_FAILED) {
        perror("sem_open");
        exit(1);
    }
   
    if ((ret = sem_post(sem)) < 0)
        perror("sem_post");
   
    sem_close(sem);
   
    exit(ret);
}
Пример #25
0
    int notification_imp::notification_thread_init()
    {
        int rc;

        sem_unlink("/notify_waiting_sem");

        if ((notify_waiting = sem_open("/notify_waiting_sem", O_CREAT | O_EXCL, 0644, 0)) == SEM_FAILED)
        {
            perror("sem_open");
            exit(-1);
        }

        rc = pthread_create(&h_thread, NULL, &notification_imp::dispatch_thread, (void *)this);
        if (rc)
        {
            printf("ERROR; return code from pthread_create() is %d\n", rc);
            exit(-1);
        }

        return 0;
    }
Пример #26
0
int main(void)
{
	sem_t *mysemp;
	char semname[50];

	sprintf(semname, "/" FUNCTION "_" TEST "_%d", getpid());

	mysemp = sem_open(semname, O_CREAT, 0777, 1);

	/* Checking if mysemp has a value returned. From sem_open */

	if (&mysemp != NULL) {
		puts("TEST PASSED");
		sem_close(mysemp);
		sem_unlink(semname);
		return PTS_PASS;
	} else {
		puts("TEST FAILED");
		return PTS_FAIL;
	}
}
Пример #27
0
  bool init()
  {
    if(lbhData != MAP_FAILED)
      return true;

    fd = shm_open(LBH_MEM_NAME, O_RDWR, S_IRUSR | S_IWUSR);
    if(fd == -1)
      return false;

    sem = sem_open(LBH_SEM_NAME, O_RDWR, S_IRUSR | S_IWUSR, 0);
    if(sem == SEM_FAILED)
    {
      close(fd);
      fd = -1;
      return false;
    }

    VERIFY((lbhData = (LBHData*)mmap(NULL, sizeof(LBHData), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) != MAP_FAILED);
    lbhData->state = okState;
    return true;
  }
Пример #28
0
int main() {
	sem_t *mysemp;
	char semname[50];
	int value = 10;
	int val;

	sprintf(semname, "/" FUNCTION "_" TEST "_%ld", (long)getpid());

	/* Initial value of Semaphore is 10 */
	mysemp = sem_open(semname, O_CREAT, 0777, value);
	if( mysemp == SEM_FAILED || mysemp == NULL ) {
		perror(ERROR_PREFIX "sem_open");
		return PTS_UNRESOLVED;
	}

	while (value)
	{ // checking the value if zero yet.
		if( sem_wait(mysemp) == -1 ) {
			perror(ERROR_PREFIX "sem_getvalue");
			return PTS_UNRESOLVED;
		} else {
			value--;
		}
	}


	if( sem_getvalue(mysemp, &val) == -1 ) {
		perror(ERROR_PREFIX "sem_getvalue");
		return PTS_UNRESOLVED;

	} else if( val == 0 ) {
		puts("TEST PASSED");
		sem_unlink(semname);
		sem_close(mysemp);
		return PTS_PASS;
	} else {
		puts("TEST FAILED: Semaphore is not locked");
		return PTS_FAIL;
	}
}
Пример #29
0
int
main (void)
{
  sem_t *s;
  int i;

  on_exit (remove_sem, (void *) "/glibc-tst-sem8");

  for (i = 0; i < 3; ++i)
    {
      s = sem_open ("/glibc-tst-sem8", O_CREAT, 0600, 1);
      if (s == SEM_FAILED)
	{
	  if (errno == ENOSYS)
	    {
	      puts ("sem_open not supported.  Oh well.");
	      return 0;
	    }

	  /* Maybe the shm filesystem has strict permissions.  */
	  if (errno == EACCES)
	    {
	      puts ("sem_open not allowed.  Oh well.");
	      return 0;
	    }

	  printf ("sem_open: %m\n");
	  return 1;
	}

      /* Now close the handle.  */
      if (sem_close (s) != 0)
	{
	  puts ("sem_close failed");
	  return 1;
	}
    }

  return 0;
}
Пример #30
-1
int main() {
	char semname[50];
	int val;

	sprintf(semname, "/" FUNCTION "_" TEST "_%ld", (long)getpid());

	gsemp = sem_open(semname, O_CREAT, 0777, SEMINITVAL);
	if( gsemp == SEM_FAILED || gsemp == NULL ) {
		perror(ERROR_PREFIX "sem_open");
		return PTS_UNRESOLVED;
	}
	signal(SIGALRM, sighdl);
	sleep(1);
        alarm(1);

	if( sem_post(gsemp) == -1 ) {
		perror(ERROR_PREFIX "sem_post");
		exit(PTS_UNRESOLVED);
	}

	/* Checking if the value of the Semaphore incremented by one */
	if( sem_getvalue(gsemp, &val) == -1 ) {
		perror(ERROR_PREFIX "sem_getvalue");
		return PTS_UNRESOLVED;
	}
	if (val != SEMINITVAL+1) {
#ifdef DEBUG
		printf("semaphore value was not incremented\n");
#endif
		printf("TEST FAILED\n");
		return PTS_FAIL;
	}

#ifdef DEBUG
	printf("semaphore value was %d\n", val);
#endif

	printf("TEST PASSED\n");
	sem_close(gsemp);
	sem_unlink(semname);
	return PTS_PASS;
}