Esempio n. 1
0
void server_loop(void)
{
	double  tick;
	double  tmr500 = 0;
	double  tmr1000 = 0;
	double  lastupdatesaveplayers = 0;
	double  lastupdatemapspawnitems = 0;
	double  lastupdateplayervitals = 0;

	while(server_is_online){
		tick = gettickcount();

		if(tick > tmr500){
			update_npc_ai();

			tmr500 = gettickcount() + .5;
		}

		if(tick > tmr1000){
			if(shutting_down())
				handle_shutdown();

			tmr1000 = gettickcount() + 1;
		}

		if(tick > lastupdateplayervitals){
			update_player_vitals();
			lastupdateplayervitals = gettickcount() + 5;
		}

		if(tick > lastupdatemapspawnitems){
			update_map_spawn_items();
			lastupdatemapspawnitems = gettickcount() + 30;
		}

		if(tick > lastupdatesaveplayers){
			update_save_players();
			lastupdatesaveplayers = gettickcount() + 60;
		}
	}
	return;
}
Esempio n. 2
0
static void	write_file(t_server *serv, int s)
{
  t_file	*file;
  char		buf[512];
  char		ret[1024];
  int		fd;
  int		r;

  if ((file = get_file_by_fd(serv->files, s)) != NULL)
    {
      sprintf(ret, ".downloads/%s", file->name);
      if ((fd = open(ret, O_RDONLY)) != -1)
	{
	  if ((r = read(fd, buf, 511)) > 0)
	    {
	      buf[r] = 0;
	      swrite(s, buf);
	      close(fd);
	    }
	  else
	    shutting_down(serv, file, ret, s);
	}
    }
}
Esempio n. 3
0
static THREAD_FUNC TapeWriteThread(void *dummy)
{
int status;
size_t blen, remain, want, put, nrec;
char *ptr;
OLD_MSGQ_MSG *obuf;
static char *fid = "TapeWriteThread";

    blen = Params->bfact * IDA_BUFSIZ; /* IDA10 OK */
    MUTEX_LOCK(&mp);
        ioerr = 0;
    MUTEX_UNLOCK(&mp);

    while (1) {

        obuf = msgq_get(&Q->obuf, OLD_MSGQ_WAITFOREVER);
        if (!msgq_chkmsg2(fid, obuf)) {
            util_log(1, "%s: corrupt message received", fid);
            ispd_die(MY_MOD_ID + 1);
        }
        nrec = *((size_t *) obuf->data);
        util_log(1, "dumping %ld records to %s", nrec, Params->odev);

        ptr = obuf->data + sizeof(size_t);
        remain = nrec * IDA_BUFSIZ; /* IDA10 OK */

        while (remain > 0) {
            want = remain > blen ? blen : remain;
            nrec = want / IDA_BUFSIZ; /* IDA10 OK */
            do {
                lock_device();
                    put = mtio_write(tp, ptr, want);
                    if (put == want) {
                        MUTEX_LOCK(&Status->lock);
                            Status->output.nrec += nrec;
                            status = Status->output.state;
                        MUTEX_UNLOCK(&Status->lock);
                        ptr += put;
                        if (ioerr) {
                            clear_alarm(ISP_ALARM_IOERR);
                            ioerr = 0;
                        }
                    } else {
                        if (put != 0) {
                            if (++ioerr == 1) {
                                set_alarm(ISP_ALARM_IOERR);
                                util_log(1, "%s: %s",
                                    Params->odev, syserrmsg(errno)
                                );
                            }
                            MUTEX_LOCK(&Status->lock);
                                ++Status->output.err;
                            MUTEX_UNLOCK(&Status->lock);
                            eject_tape(0);
                        }
                    }
                release_device();
                if (put != want) {
                    if (shutting_down()) {
                        complete_shutdown();
                        THREAD_EXIT(0);
                    } else {
                        sleep(5);
                    }
                }
            } while (put != want);
            remain -= put;
        }
        util_log(1, "tape dump completed OK");

        if (shutting_down()) {
            complete_shutdown();
            THREAD_EXIT(0);
        }

        MUTEX_LOCK(&mp);
            if (eject_flag) eject_tape(0);
            eject_flag = 0;
        MUTEX_UNLOCK(&mp);

        msgq_put(&Heap->obuf, obuf);
    }
}
Esempio n. 4
0
static THREAD_FUNC TapeWatchThread(void *dummy)
{
int boot_flag;
static struct mtget info;
static char *fid = "TapeWatchThread";

    boot_flag = 1;
    util_log(2, "TAPE_WATCH thread started, tid = %d", THREAD_SELF());

    set_alarm(ISP_ALARM_OFFLINE);

    while (1) {
        
        MUTEX_LOCK(&mp);

        /* if we were offline, see if a tape is now present */

            if (prev_state == MTIO_OFFLINE) {
                if ((tp = mtio_open(Params->odev, "w")) != null) {
                    if (mtio_status(tp, &info) != -1) {
                        crnt_state = MTIO_ONLINE;
                        clear_alarm(ISP_ALARM_OFFLINE);
                        if (ioerr) {
                            clear_alarm(ISP_ALARM_IOERR);
                            ioerr = 0;
                        }
                        check_tape(boot_flag);
                    } else {
                        mtio_close(tp); tp = (TAPE *) NULL;
                    }
                }

                if (tp == null && shutting_down()) {
                    util_log(1, "shutting down w/o final flush (no tape)");
                    complete_shutdown();
                }

        /* if we were on-line, make sure we still are that way */
        /* THIS CODE DOES NOT WORK AND I DON'T KNOW HOW TO MAKE IT WORK! */

            } else if (mtio_nop(tp) < 0 || mtio_status(tp, &info) < 0) {
                mtio_close(tp); tp = (TAPE *) tp;
                set_alarm(ISP_ALARM_OFFLINE);
                crnt_state = MTIO_OFFLINE;
            }

            if (crnt_state != prev_state) {
                MUTEX_LOCK(&Status->lock);
                    if (crnt_state == MTIO_ONLINE) {
                        Status->output.state = ISP_OUTPUT_ONLINE;
                        Status->output.err   = 0;
                        Status->output.file  = info.mt_fileno + 1;
                        Status->output.nrec  = 0;
                    } else {
                        Status->output.state = ISP_OUTPUT_OFFLINE;
                    }
                MUTEX_UNLOCK(&Status->lock);
            }

            prev_state = crnt_state;
            boot_flag = 0;

            if (pending && (crnt_state == MTIO_ONLINE)) {
                pending = 0;
                SEM_POST(&sp);
            }

        MUTEX_UNLOCK(&mp);

        sleep(10);
    }
}