#include "std.h"
#include "port.h"
#include "file_incl.h"
#include "network_incl.h"
#include <unistd.h>
#ifndef MINGW
#include <sys/mman.h>
#endif
#if defined(WIN32)
int dos_style_link (char * x, char * y) {
    char link_cmd[100];
    sprintf(link_cmd, "copy %s %s", x, y);
    return system(link_cmd);
}
#endif

/* for get_cpu_times() */
#ifdef GET_PROCESS_STATS
#include <sys/procstats.h>
#endif
#ifdef RUSAGE
#include <sys/resource.h>
#endif

#ifdef sun
time_t time (time_t *);
#endif

/*
 * Return a pseudo-random number in the range 0 .. n-1
 */
long random_number (long n)
{
#if defined(RAND) || defined(DRAND48)
    static char called = 0;

    if (!called) {
	time_t tim;

	time(&tim);
#  ifdef RAND
	srand(tim);
#  else
	srand48(tim);
#  endif
	called = 1;
    }				/* endif */
#  ifdef RAND
#    ifdef MINGW
    return rand() % n;
#    else
    return 1 + (long) ((float)n * rand() / (RAND_MAX+1.0);
#endif
#  else
    return (long)(drand48() * n);
#  endif
#else
#  ifdef RANDOM
    return random() % n;
#  else				/* RANDOM */
    return current_time % n;	/* You really don't want to use this method */
#  endif			/* RANDOM */
#endif				/* RAND */
}

/*
 * The function time() can't really be trusted to return an integer.
 * But MudOS uses the 'current_time', which is an integer number
 * of seconds. To make this more portable, the following functions
 * should be defined in such a way as to return the number of seconds since
 * some chosen year. The old behaviour of time(), is to return the number
 * of seconds since 1970.
 */

long get_current_time()
{
    return time(0l);	/* Just use the old time() for now */
}

const char *time_string (time_t t)
{
    const char *res = ctime(&t);
    if(!res)
      res = "ctime failed";
    return res;
}

/*
 * Initialize the microsecond clock.
 */
void init_usec_clock()
{
#ifdef _SEQUENT_
    usclk_init();
#endif
}

/*
 * Get a microsecond clock sample.
 */
void
get_usec_clock (long * sec, long * usec)
{
#ifdef HAS_GETTIMEOFDAY
    struct timeval tv;

    gettimeofday(&tv, NULL);
    *sec = tv.tv_sec;
    *usec = tv.tv_usec;
#else
#ifdef _SEQUENT_
           *sec = 0;
    *usec = GETUSCLK();
#else
    *sec = time(0);
    *usec = 0;
#endif
#endif
}

#ifdef USE_POSIX_SIGNALS
int
port_sigblock (sigset_t mask)
{
    sigset_t omask;

    sigprocmask(SIG_BLOCK, &mask, &omask);
    return (omask);
}

int
port_sigmask (int sig)
{
    sigset_t set;

    sigemptyset(&set);
    sigaddset(&set, sig);
    return (set);
}

void
     (*port_signal(sig, func)) ()
    int sig;
    void (*func) ();
{
    struct sigaction act, oact;

    act.sa_handler = func;
    act.sa_mask = 0;
    act.sa_flags = 0;
    if (sigaction(sig, &act, &oact) == -1)
	return ((void (*) ()) -1);
    return (oact.sa_handler);
}

int
port_sigsetmask (sigset_t mask)
{
    sigset_t omask;

    sigprocmask(SIG_SETMASK, &mask, &omask);
    return (omask);
}
#endif

int
get_cpu_times (unsigned long * secs, unsigned long * usecs)
{
#ifdef RUSAGE
    struct rusage rus;
#endif
#if defined(TIMES) && !defined(RUSAGE)
    struct tms t;
    unsigned long total;
#endif
#ifdef GET_PROCESS_STATS
    struct process_stats ps;
#endif

#ifdef RUSAGE			/* start RUSAGE */
    if (getrusage(RUSAGE_SELF, &rus) < 0) {
	return 0;
    }
    *secs = rus.ru_utime.tv_sec + rus.ru_stime.tv_sec;
    *usecs = rus.ru_utime.tv_usec + rus.ru_stime.tv_usec;
    return 1;
#else				/* end then RUSAGE */

#ifdef GET_PROCESS_STATS	/* start GET_PROCESS_STATS */
    if (get_process_stats(NULL, PS_SELF, &ps, NULL) == -1) {
	return 0;
    }
    *secs = ps.ps_utime.tv_sec + ps.ps_stime.tv_sec;
    *usecs = ps.ps_utime.tv_usec + ps.ps_stime.tv_usec;
    return 1;
#else				/* end then GET_PROCESS_STATS */

#ifdef TIMES			/* start TIMES */
    times(&t);
    *secs = (total = t.tms_utime + t.tms_stime) / CLK_TCK;
    *usecs = ((total - (*secs * CLK_TCK)) * 1000000) / CLK_TCK;
    return 1;
#else				/* end then TIMES */

    return 0;
#endif				/* end TIMES */
#endif				/* end else GET_PROCESS_STATS */
#endif				/* end else RUSAGE */
}

/* return the current working directory */
char *
     get_current_dir (char * buf, int limit)
{
#ifdef HAS_GETCWD
    return getcwd(buf, limit);	/* POSIX */
#else
    return getwd(buf);		/* BSD */
#endif
}

#ifndef HAS_STRERROR
/* for those systems without strerror() but with sys_errlist, sys_nerr */
/* Warning: Sun has a prototype for strerror, but no definition for it,
   so we can't use that name */
extern char *sys_errlist[];
extern int sys_nerr;

char *port_strerror (int which)
{
    if ((which < 0) || (which >= sys_nerr)) {
	return "unknown error";
    } else {
	return sys_errlist[which];
    }
}
#endif				/* STRERROR */

#ifdef MEMMOVE_MISSING
/* for those without memmove() and a working bcopy() that can handle overlaps */
INLINE char *memmove (register char * b, register char * a, register int s)
{
    char *r = b;

    if (b < a) {
	while (s--)
	    *(b++) = *(a++);
    } else if (b > a) {
	b += s;
	a += s;
	while (s--)
	    *(--b) = *(--a);
    }
    return r;
}
#endif

#ifdef WIN32
char *WinStrError(int err) {
    static char buf[30];
    if (errno < 10000) return strerror(err);
    sprintf(buf, "error #%d", err);
    return buf;
}
#endif

#ifdef MMAP_SBRK
void * sbrkx(long size){
  static void *end = 0;
  static unsigned long tsize = 0;
  void *tmp, *result;
  long long newsize;
  if(!end){
    tmp = mmap((void *)0x41000000, 4096, PROT_READ|PROT_WRITE, MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS,0,0);
    tsize=4096;
    end=(void *)0x41000000;
    if(tmp != end)
      return NULL;
  }

  newsize = (long)end + size;
  result = end;
  end = newsize;
  newsize &= 0xFFFFF000;
  newsize += 0x1000;
  newsize -= 0x41000000;

  tmp = mremap((void *)0x41000000, tsize, newsize, 0);

  if(tmp != (void *) 0x41000000)
    return NULL;

  tsize = newsize;
  return result;
}

#else

void *sbrkx(long size){
#ifndef MINGW
  return sbrk(size);
#endif
}
#endif