开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
fluid_sys.c
资源名称：trunk-r284.zip　[点击查看]
上传用户：tjmskj2
上传日期：2020-08-17
资源大小：577k
文件大小：27k
源码类别：

midi

开发平台：

C/C++

fluid_sys.c：源码内容
  1. /* FluidSynth - A Software Synthesizer
  2.  *
  3.  * Copyright (C) 2003  Peter Hanappe and others.
  4.  *
  5.  * This library is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU Library General Public License
  7.  * as published by the Free Software Foundation; either version 2 of
  8.  * the License, or (at your option) any later version.
  9.  *
  10.  * This library is distributed in the hope that it will be useful, but
  11.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  * Library General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU Library General Public
  16.  * License along with this library; if not, write to the Free
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18.  * 02111-1307, USA
  19.  */
  21. #include "fluid_sys.h"
  24. #if WITH_READLINE
  25. #include <readline/readline.h>
  26. #include <readline/history.h>
  27. #endif
  29. /* WIN32 HACK - Flag used to differentiate between a file descriptor and a socket.
  30.  * Should work, so long as no SOCKET or file descriptor ends up with this bit set. - JG */
  31. #define WIN32_SOCKET_FLAG       0x40000000
  33. /* SCHED_FIFO priority for high priority timer threads */
  34. #define FLUID_SYS_TIMER_HIGH_PRIO_LEVEL         10
  37. typedef struct
  38. {
  39.   fluid_thread_func_t func;
  40.   void *data;
  41.   int prio_level;
  42. } fluid_thread_info_t;
  44. struct _fluid_timer_t
  45. {
  46.   long msec;
  47.   fluid_timer_callback_t callback;
  48.   void *data;
  49.   fluid_thread_t *thread;
  50.   int cont;
  51.   int auto_destroy;
  52. };
  54. struct _fluid_server_socket_t
  55. {
  56.   fluid_socket_t socket;
  57.   fluid_thread_t *thread;
  58.   int cont;
  59.   fluid_server_func_t func;
  60.   void *data;
  61. };
  64. static int fluid_istream_gets(fluid_istream_t in, char* buf, int len);
  67. static char fluid_errbuf[512];  /* buffer for error message */
  69. static fluid_log_function_t fluid_log_function[LAST_LOG_LEVEL];
  70. static void* fluid_log_user_data[LAST_LOG_LEVEL];
  71. static int fluid_log_initialized = 0;
  73. static char* fluid_libname = "fluidsynth";
  76. void fluid_sys_config()
  77. {
  78.   fluid_log_config();
  79. }
  82. unsigned int fluid_debug_flags = 0;
  84. #if DEBUG
  85. /*
  86.  * fluid_debug
  87.  */
  88. int fluid_debug(int level, char * fmt, ...)
  89. {
  90.   if (fluid_debug_flags & level) {
  91.     fluid_log_function_t fun;
  92.     va_list args;
  94.     va_start (args, fmt);
  95.     vsnprintf(fluid_errbuf, sizeof (fluid_errbuf), fmt, args);
  96.     va_end (args);
  98.     fun = fluid_log_function[FLUID_DBG];
  99.     if (fun != NULL) {
  100.       (*fun)(level, fluid_errbuf, fluid_log_user_data[FLUID_DBG]);
  101.     }
  102.   }
  103.   return 0;
  104. }
  105. #endif
  107. /**
  108.  * Installs a new log function for a specified log level.
  109.  * @param level Log level to install handler for.
  110.  * @param fun Callback function handler to call for logged messages
  111.  * @param data User supplied data pointer to pass to log function
  112.  * @return The previously installed function.
  113.  */
  114. fluid_log_function_t
  115. fluid_set_log_function(int level, fluid_log_function_t fun, void* data)
  116. {
  117.   fluid_log_function_t old = NULL;
  119.   if ((level >= 0) && (level < LAST_LOG_LEVEL)) {
  120.     old = fluid_log_function[level];
  121.     fluid_log_function[level] = fun;
  122.     fluid_log_user_data[level] = data;
  123.   }
  124.   return old;
  125. }
  127. /**
  128.  * Default log function which prints to the stderr.
  129.  * @param level Log level
  130.  * @param message Log message
  131.  * @param data User supplied data (not used)
  132.  */
  133. void
  134. fluid_default_log_function(int level, char* message, void* data)
  135. {
  136.   FILE* out;
  138. #if defined(WIN32)
  139.   out = stdout;
  140. #else
  141.   out = stderr;
  142. #endif
  144.   if (fluid_log_initialized == 0) {
  145.     fluid_log_config();
  146.   }
  148.   switch (level) {
  149.   case FLUID_PANIC:
  150.     FLUID_FPRINTF(out, "%s: panic: %sn", fluid_libname, message);
  151.     break;
  152.   case FLUID_ERR:
  153.     FLUID_FPRINTF(out, "%s: error: %sn", fluid_libname, message);
  154.     break;
  155.   case FLUID_WARN:
  156.     FLUID_FPRINTF(out, "%s: warning: %sn", fluid_libname, message);
  157.     break;
  158.   case FLUID_INFO:
  159.     FLUID_FPRINTF(out, "%s: %sn", fluid_libname, message);
  160.     break;
  161.   case FLUID_DBG:
  162. #if DEBUG
  163.     FLUID_FPRINTF(out, "%s: debug: %sn", fluid_libname, message);
  164. #endif
  165.     break;
  166.   default:
  167.     FLUID_FPRINTF(out, "%s: %sn", fluid_libname, message);
  168.     break;
  169.   }
  170.   fflush(out);
  171. }
  173. /*
  174.  * fluid_init_log
  175.  */
  176. void
  177. fluid_log_config(void)
  178. {
  179.   if (fluid_log_initialized == 0) {
  181.     fluid_log_initialized = 1;
  183.     if (fluid_log_function[FLUID_PANIC] == NULL) {
  184.       fluid_set_log_function(FLUID_PANIC, fluid_default_log_function, NULL);
  185.     }
  187.     if (fluid_log_function[FLUID_ERR] == NULL) {
  188.       fluid_set_log_function(FLUID_ERR, fluid_default_log_function, NULL);
  189.     }
  191.     if (fluid_log_function[FLUID_WARN] == NULL) {
  192.       fluid_set_log_function(FLUID_WARN, fluid_default_log_function, NULL);
  193.     }
  195.     if (fluid_log_function[FLUID_INFO] == NULL) {
  196.       fluid_set_log_function(FLUID_INFO, fluid_default_log_function, NULL);
  197.     }
  199.     if (fluid_log_function[FLUID_DBG] == NULL) {
  200.       fluid_set_log_function(FLUID_DBG, fluid_default_log_function, NULL);
  201.     }
  202.   }
  203. }
  205. /**
  206.  * Print a message to the log.
  207.  * @param level Log level (#fluid_log_level).
  208.  * @param fmt Printf style format string for log message
  209.  * @param ... Arguments for printf 'fmt' message string
  210.  * @return Always returns #FLUID_FAILED
  211.  */
  212. int
  213. fluid_log(int level, const char* fmt, ...)
  214. {
  215.   fluid_log_function_t fun = NULL;
  217.   va_list args;
  218.   va_start (args, fmt);
  219.   vsnprintf(fluid_errbuf, sizeof (fluid_errbuf), fmt, args);
  220.   va_end (args);
  222.   if ((level >= 0) && (level < LAST_LOG_LEVEL)) {
  223.     fun = fluid_log_function[level];
  224.     if (fun != NULL) {
  225.       (*fun)(level, fluid_errbuf, fluid_log_user_data[level]);
  226.     }
  227.   }
  228.   return FLUID_FAILED;
  229. }
  231. /**
  232.  * An improved strtok, still trashes the input string, but is portable and
  233.  * thread safe.  Also skips token chars at beginning of token string and never
  234.  * returns an empty token (will return NULL if source ends in token chars though).
  235.  * NOTE: NOT part of public API
  236.  * @internal
  237.  * @param str Pointer to a string pointer of source to tokenize.  Pointer gets
  238.  *   updated on each invocation to point to beginning of next token.  Note that
  239.  *   token char get's overwritten with a 0 byte.  String pointer is set to NULL
  240.  *   when final token is returned.
  241.  * @param delim String of delimiter chars.
  242.  * @return Pointer to the next token or NULL if no more tokens.
  243.  */
  244. char *fluid_strtok (char **str, char *delim)
  245. {
  246.   char *s, *d, *token;
  247.   char c;
  249.   if (str == NULL || delim == NULL || !*delim)
  250.   {
  251.     FLUID_LOG(FLUID_ERR, "Null pointer");
  252.     return NULL;
  253.   }
  255.   s = *str;
  256.   if (!s) return NULL; /* str points to a NULL pointer? (tokenize already ended) */
  258.   /* skip delimiter chars at beginning of token */
  259.   do
  260.   {
  261.     c = *s;
  262.     if (!c) /* end of source string? */
  263.     {
  264.       *str = NULL;
  265.       return NULL;
  266.     }
  268.     for (d = delim; *d; d++) /* is source char a token char? */
  269.     {
  270.       if (c == *d) /* token char match? */
  271.       {
  272. s++; /* advance to next source char */
  273. break;
  274.       }
  275.     }
  276.   } while (*d); /* while token char match */
  278.   token = s; /* start of token found */
  280.   /* search for next token char or end of source string */
  281.   for (s = s+1; *s; s++)
  282.   {
  283.     c = *s;
  285.     for (d = delim; *d; d++) /* is source char a token char? */
  286.     {
  287.       if (c == *d) /* token char match? */
  288.       {
  289. *s = ''; /* overwrite token char with zero byte to terminate token */
  290. *str = s+1; /* update str to point to beginning of next token */
  291. return token;
  292.       }
  293.     }
  294.   }
  296.   /* we get here only if source string ended */
  297.   *str = NULL;
  298.   return token;
  299. }
  301. /*
  302.  * fluid_error
  303.  */
  304. char*
  305. fluid_error()
  306. {
  307.   return fluid_errbuf;
  308. }
  310. /**
  311.  * Check if a file is a MIDI file.
  312.  * @param filename Path to the file to check
  313.  * @return TRUE if it could be a MIDI file, FALSE otherwise
  314.  *
  315.  * The current implementation only checks for the "MThd" header in the file.
  316.  * It is useful only to distinguish between SoundFont and MIDI files.
  317.  */
  318. int
  319. fluid_is_midifile(const char *filename)
  320. {
  321.   FILE* fp = fopen(filename, "rb");
  322.   char id[4];
  324.   if (fp == NULL) {
  325.     return 0;
  326.   }
  327.   if (fread((void*) id, 1, 4, fp) != 4) {
  328.     fclose(fp);
  329.     return 0;
  330.   }
  331.   fclose(fp);
  333.   return strncmp(id, "MThd", 4) == 0;
  334. }
  336. /**
  337.  * Check if a file is a SoundFont file.
  338.  * @param filename Path to the file to check
  339.  * @return TRUE if it could be a SoundFont, FALSE otherwise
  340.  *
  341.  * The current implementation only checks for the "RIFF" header in the file.
  342.  * It is useful only to distinguish between SoundFont and MIDI files.
  343.  */
  344. int
  345. fluid_is_soundfont(const char *filename)
  346. {
  347.   FILE* fp = fopen(filename, "rb");
  348.   char id[4];
  350.   if (fp == NULL) {
  351.     return 0;
  352.   }
  353.   if (fread((void*) id, 1, 4, fp) != 4) {
  354.     fclose(fp);
  355.     return 0;
  356.   }
  357.   fclose(fp);
  359.   return strncmp(id, "RIFF", 4) == 0;
  360. }
  362. /**
  363.  * Get time in milliseconds to be used in relative timing operations.
  364.  * @return Unix time in milliseconds.
  365.  */
  366. unsigned int fluid_curtime(void)
  367. {
  368.   GTimeVal timeval;
  370.   g_get_current_time (&timeval);
  372.   return (timeval.tv_sec * 1000.0 + timeval.tv_usec / 1000.0);
  373. }
  375. /**
  376.  * Get time in microseconds to be used in relative timing operations.
  377.  * @return Unix time in microseconds.
  378.  */
  379. double
  380. fluid_utime (void)
  381. {
  382.   GTimeVal timeval;
  384.   g_get_current_time (&timeval);
  386.   return (timeval.tv_sec * 1000000.0 + timeval.tv_usec);
  387. }
  390. #if defined(WIN32)      /* Windoze specific stuff */
  392. void
  393. fluid_thread_self_set_prio (int prio_level)
  394. {
  395.   if (prio_level > 0)
  396.     SetThreadPriority (GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
  397. }
  400. #elif defined(__OS2__)  /* OS/2 specific stuff */
  402. void
  403. fluid_thread_self_set_prio (int prio_level)
  404. {
  405.   if (prio_level > 0)
  406.     DosSetPriority (PRTYS_THREAD, PRTYC_REGULAR, PRTYD_MAXIMUM, 0);
  407. }
  409. #else   /* POSIX stuff..  Nice POSIX..  Good POSIX. */
  411. void
  412. fluid_thread_self_set_prio (int prio_level)
  413. {
  414.   struct sched_param priority;
  416.   if (prio_level > 0)
  417.   {
  418.     priority.sched_priority = prio_level;
  420.     if (pthread_setschedparam (pthread_self (), SCHED_FIFO, &priority) != 0)
  421.       FLUID_LOG(FLUID_WARN, "Failed to set thread to high priority");
  422.   }
  423. }
  425. #ifdef FPE_CHECK
  427. /***************************************************************
  428.  *
  429.  *               Floating point exceptions
  430.  *
  431.  *  The floating point exception functions were taken from Ircam's
  432.  *  jMax source code. http://www.ircam.fr/jmax
  433.  *
  434.  *  FIXME: check in config for i386 machine
  435.  *
  436.  *  Currently not used. I leave the code here in case we want to pick
  437.  *  this up again some time later.
  438.  */
  440. /* Exception flags */
  441. #define _FPU_STATUS_IE    0x001  /* Invalid Operation */
  442. #define _FPU_STATUS_DE    0x002  /* Denormalized Operand */
  443. #define _FPU_STATUS_ZE    0x004  /* Zero Divide */
  444. #define _FPU_STATUS_OE    0x008  /* Overflow */
  445. #define _FPU_STATUS_UE    0x010  /* Underflow */
  446. #define _FPU_STATUS_PE    0x020  /* Precision */
  447. #define _FPU_STATUS_SF    0x040  /* Stack Fault */
  448. #define _FPU_STATUS_ES    0x080  /* Error Summary Status */
  450. /* Macros for accessing the FPU status word.  */
  452. /* get the FPU status */
  453. #define _FPU_GET_SW(sw) __asm__ ("fnstsw %0" : "=m" (*&sw))
  455. /* clear the FPU status */
  456. #define _FPU_CLR_SW() __asm__ ("fnclex" : : )
  458. /* Purpose:
  459.  * Checks, if the floating point unit has produced an exception, print a message
  460.  * if so and clear the exception.
  461.  */
  462. unsigned int fluid_check_fpe_i386(char* explanation)
  463. {
  464.   unsigned int s;
  466.   _FPU_GET_SW(s);
  467.   _FPU_CLR_SW();
  469.   s &= _FPU_STATUS_IE | _FPU_STATUS_DE | _FPU_STATUS_ZE | _FPU_STATUS_OE | _FPU_STATUS_UE;
  471.   if (s)
  472.   {
  473.       FLUID_LOG(FLUID_WARN, "FPE exception (before or in %s): %s%s%s%s%s", explanation,
  474.        (s & _FPU_STATUS_IE) ? "Invalid operation " : "",
  475.        (s & _FPU_STATUS_DE) ? "Denormal number " : "",
  476.        (s & _FPU_STATUS_ZE) ? "Zero divide " : "",
  477.        (s & _FPU_STATUS_OE) ? "Overflow " : "",
  478.        (s & _FPU_STATUS_UE) ? "Underflow " : "");
  479.   }
  481.   return s;
  482. }
  484. /* Purpose:
  485.  * Clear floating point exception.
  486.  */
  487. void fluid_clear_fpe_i386 (void)
  488. {
  489.   _FPU_CLR_SW();
  490. }
  492. #endif // ifdef FPE_CHECK
  495. #endif // #else    (its POSIX)
  498. /***************************************************************
  499.  *
  500.  *               Profiling (Linux, i586 only)
  501.  *
  502.  */
  504. #if WITH_PROFILING
  506. fluid_profile_data_t fluid_profile_data[] =
  507. {
  508.   { FLUID_PROF_WRITE_S16,        "fluid_synth_write_s16           ", 1e10, 0.0, 0.0, 0},
  509.   { FLUID_PROF_ONE_BLOCK,        "fluid_synth_one_block           ", 1e10, 0.0, 0.0, 0},
  510.   { FLUID_PROF_ONE_BLOCK_CLEAR,  "fluid_synth_one_block:clear     ", 1e10, 0.0, 0.0, 0},
  511.   { FLUID_PROF_ONE_BLOCK_VOICE,  "fluid_synth_one_block:one voice ", 1e10, 0.0, 0.0, 0},
  512.   { FLUID_PROF_ONE_BLOCK_VOICES, "fluid_synth_one_block:all voices", 1e10, 0.0, 0.0, 0},
  513.   { FLUID_PROF_ONE_BLOCK_REVERB, "fluid_synth_one_block:reverb    ", 1e10, 0.0, 0.0, 0},
  514.   { FLUID_PROF_ONE_BLOCK_CHORUS, "fluid_synth_one_block:chorus    ", 1e10, 0.0, 0.0, 0},
  515.   { FLUID_PROF_VOICE_NOTE,       "fluid_voice:note                ", 1e10, 0.0, 0.0, 0},
  516.   { FLUID_PROF_VOICE_RELEASE,    "fluid_voice:release             ", 1e10, 0.0, 0.0, 0},
  517.   { FLUID_PROF_LAST, "last", 1e100, 0.0, 0.0, 0}
  518. };
  521. void fluid_profiling_print(void)
  522. {
  523.   int i;
  525.   printf("fluid_profiling_printn");
  527.   FLUID_LOG(FLUID_INFO, "Estimated times: min/avg/max (micro seconds)");
  529.   for (i = 0; i < FLUID_PROF_LAST; i++) {
  530.     if (fluid_profile_data[i].count > 0) {
  531.       FLUID_LOG(FLUID_INFO, "%s: %.3f/%.3f/%.3f",
  532.        fluid_profile_data[i].description,
  533.        fluid_profile_data[i].min,
  534.        fluid_profile_data[i].total / fluid_profile_data[i].count,
  535.        fluid_profile_data[i].max);
  536.     } else {
  537.       FLUID_LOG(FLUID_DBG, "%s: no profiling available", fluid_profile_data[i].description);
  538.     }
  539.   }
  540. }
  543. #endif /* WITH_PROFILING */
  547. /***************************************************************
  548.  *
  549.  *               Threads
  550.  *
  551.  */
  553. /* Rather than inline this one, we just declare it as a function, to prevent
  554.  * GCC warning about inline failure. */
  555. fluid_cond_t *
  556. new_fluid_cond (void)
  557. {
  558.   if (!g_thread_supported ()) g_thread_init (NULL);
  559.   return g_cond_new ();
  560. }
  562. static gpointer
  563. fluid_thread_high_prio (gpointer data)
  564. {
  565.   fluid_thread_info_t *info = data;
  567.   fluid_thread_self_set_prio (info->prio_level);
  569.   info->func (info->data);
  570.   FLUID_FREE (info);
  572.   return NULL;
  573. }
  575. /**
  576.  * Create a new thread.
  577.  * @param func Function to execute in new thread context
  578.  * @param data User defined data to pass to func
  579.  * @param prio_level Priority level.  If greater than 0 then high priority scheduling will
  580.  *   be used, with the given priority level (used by pthreads only).  0 uses normal scheduling.
  581.  * @param detach If TRUE, 'join' does not work and the thread destroys itself when finished.
  582.  * @return New thread pointer or NULL on error
  583.  */
  584. fluid_thread_t *
  585. new_fluid_thread (fluid_thread_func_t func, void *data, int prio_level, int detach)
  586. {
  587.   GThread *thread;
  588.   fluid_thread_info_t *info;
  589.   GError *err = NULL;
  591.   g_return_val_if_fail (func != NULL, NULL);
  593.   /* Make sure g_thread_init has been called.
  594.    * FIXME - Probably not a good idea in a shared library,
  595.    * but what can we do *and* remain backwards compatible? */
  596.   if (!g_thread_supported ()) g_thread_init (NULL);
  598.   if (prio_level > 0)
  599.   {
  600.     info = FLUID_NEW (fluid_thread_info_t);
  602.     if (!info)
  603.     {
  604.       FLUID_LOG(FLUID_ERR, "Out of memory");
  605.       return NULL;
  606.     }
  608.     info->func = func;
  609.     info->data = data;
  610.     info->prio_level = prio_level;
  611.     thread = g_thread_create (fluid_thread_high_prio, info, detach == FALSE, &err);
  612.   }
  613.   else thread = g_thread_create ((GThreadFunc)func, data, detach == FALSE, &err);
  615.   if (!thread)
  616.   {
  617.     FLUID_LOG(FLUID_ERR, "Failed to create the thread: %s",
  618.               fluid_gerror_message (err));
  619.     g_clear_error (&err);
  620.   }
  622.   return thread;
  623. }
  625. /**
  626.  * Frees data associated with a thread (does not actually stop thread).
  627.  * @param thread Thread to free
  628.  */
  629. void
  630. delete_fluid_thread(fluid_thread_t* thread)
  631. {
  632.   /* Threads free themselves when they quit, nothing to do */
  633. }
  635. /**
  636.  * Join a thread (wait for it to terminate).
  637.  * @param thread Thread to join
  638.  * @return FLUID_OK
  639.  */
  640. int
  641. fluid_thread_join(fluid_thread_t* thread)
  642. {
  643.   g_thread_join (thread);
  645.   return FLUID_OK;
  646. }
  649. void
  650. fluid_timer_run (void *data)
  651. {
  652.   fluid_timer_t *timer;
  653.   int count = 0;
  654.   int cont;
  655.   long start;
  656.   long delay;
  658.   timer = (fluid_timer_t *)data;
  660.   /* keep track of the start time for absolute positioning */
  661.   start = fluid_curtime ();
  663.   while (timer->cont)
  664.   {
  665.     cont = (*timer->callback)(timer->data, fluid_curtime() - start);
  667.     count++;
  668.     if (!cont) break;
  670.     /* to avoid incremental time errors, calculate the delay between
  671.        two callbacks bringing in the "absolute" time (count *
  672.        timer->msec) */
  673.     delay = (count * timer->msec) - (fluid_curtime() - start);
  674.     if (delay > 0) g_usleep (delay * 1000);
  675.   }
  677.   FLUID_LOG (FLUID_DBG, "Timer thread finished");
  679.   if (timer->auto_destroy)
  680.     FLUID_FREE (timer);
  682.   return;
  683. }
  685. fluid_timer_t*
  686. new_fluid_timer (int msec, fluid_timer_callback_t callback, void* data,
  687.                  int new_thread, int auto_destroy, int high_priority)
  688. {
  689.   fluid_timer_t *timer;
  691.   timer = FLUID_NEW (fluid_timer_t);
  693.   if (timer == NULL)
  694.   {
  695.     FLUID_LOG (FLUID_ERR, "Out of memory");
  696.     return NULL;
  697.   }
  699.   timer->msec = msec;
  700.   timer->callback = callback;
  701.   timer->data = data;
  702.   timer->cont = TRUE ;
  703.   timer->thread = NULL;
  704.   timer->auto_destroy = auto_destroy;
  706.   if (new_thread)
  707.   {
  708.     timer->thread = new_fluid_thread (fluid_timer_run, timer, high_priority
  709.                                       ? FLUID_SYS_TIMER_HIGH_PRIO_LEVEL : 0, FALSE);
  710.     if (!timer->thread)
  711.     {
  712.       FLUID_FREE (timer);
  713.       return NULL;
  714.     }
  715.   }
  716.   else fluid_timer_run (timer);  /* Run directly, instead of as a separate thread */
  718.   return timer;
  719. }
  721. int
  722. delete_fluid_timer (fluid_timer_t *timer)
  723. {
  724.   int auto_destroy = timer->auto_destroy;
  726.   timer->cont = 0;
  727.   fluid_timer_join (timer);
  729.   /* Shouldn't access timer now if auto_destroy enabled, since it has been destroyed */
  731.   if (!auto_destroy) FLUID_FREE (timer);
  733.   return FLUID_OK;
  734. }
  736. int
  737. fluid_timer_join (fluid_timer_t *timer)
  738. {
  739.   int auto_destroy;
  741.   if (timer->thread)
  742.   {
  743.     auto_destroy = timer->auto_destroy;
  744.     fluid_thread_join (timer->thread);
  746.     if (!auto_destroy) timer->thread = NULL;
  747.   }
  749.   return FLUID_OK;
  750. }
  753. /***************************************************************
  754.  *
  755.  *               Sockets and I/O
  756.  *
  757.  */
  759. /**
  760.  * Get standard in stream handle.
  761.  * @return Standard in stream.
  762.  */
  763. fluid_istream_t
  764. fluid_get_stdin (void)
  765. {
  766.   return STDIN_FILENO;
  767. }
  769. /**
  770.  * Get standard output stream handle.
  771.  * @return Standard out stream.
  772.  */
  773. fluid_ostream_t
  774. fluid_get_stdout (void)
  775. {
  776.   return STDOUT_FILENO;
  777. }
  779. /**
  780.  * Read a line from an input stream.
  781.  * @return 0 if end-of-stream, -1 if error, non zero otherwise
  782.  */
  783. int
  784. fluid_istream_readline (fluid_istream_t in, fluid_ostream_t out, char* prompt,
  785.                         char* buf, int len)
  786. {
  787. #if WITH_READLINE
  788.   if (in == fluid_get_stdin ())
  789.   {
  790.     char *line;
  792.     line = readline (prompt);
  794.     if (line == NULL)
  795.       return -1;
  797.     snprintf(buf, len, "%s", line);
  798.     buf[len - 1] = 0;
  800.     free(line);
  801.     return 1;
  802.   }
  803.   else
  804. #endif
  805.   {
  806.     fluid_ostream_printf (out, "%s", prompt);
  807.     return fluid_istream_gets (in, buf, len);
  808.   }
  809. }
  811. /**
  812.  * Reads a line from an input stream (socket).
  813.  * @param in The input socket
  814.  * @param buf Buffer to store data to
  815.  * @param len Maximum length to store to buf
  816.  * @return 1 if a line was read, 0 on end of stream, -1 on error
  817.  */
  818. static int
  819. fluid_istream_gets (fluid_istream_t in, char* buf, int len)
  820. {
  821.   char c;
  822.   int n;
  824.   buf[len - 1] = 0;
  826.   while (--len > 0)
  827.   {
  828. #ifndef WIN32
  829.     n = read(in, &c, 1);
  830.     if (n == -1) return -1;
  831. #else
  832.     /* Handle read differently depending on if its a socket or file descriptor */
  833.     if (!(in & WIN32_SOCKET_FLAG))
  834.     {
  835.       n = read(in, &c, 1);
  836.       if (n == -1) return -1;
  837.     }
  838.     else
  839.     {
  840.       n = recv(in & ~WIN32_SOCKET_FLAG, &c, 1, 0);
  841.       if (n == SOCKET_ERROR) return -1;
  842.     }
  843. #endif
  845.     if (n == 0)
  846.     {
  847.       *buf++ = 0;
  848.       return 0;
  849.     }
  851.     if ((c == 'n'))
  852.     {
  853.       *buf++ = 0;
  854.       return 1;
  855.     }
  857.     /* Store all characters excluding CR */
  858.     if (c != 'r') *buf++ = c;
  859.   }
  861.   return -1;
  862. }
  864. /**
  865.  * Send a printf style string with arguments to an output stream (socket).
  866.  * @param out Output stream
  867.  * @param format printf style format string
  868.  * @param ... Arguments for the printf format string
  869.  * @return Number of bytes written or -1 on error
  870.  */
  871. int
  872. fluid_ostream_printf (fluid_ostream_t out, char* format, ...)
  873. {
  874.   char buf[4096];
  875.   va_list args;
  876.   int len;
  878.   va_start (args, format);
  879.   len = vsnprintf (buf, 4095, format, args);
  880.   va_end (args);
  882.   if (len <= 0)
  883.   {
  884.     printf("fluid_ostream_printf: buffer overflow");
  885.     return -1;
  886.   }
  888.   buf[4095] = 0;
  890. #ifndef WIN32
  891.   return write (out, buf, strlen (buf));
  892. #else
  893.   {
  894.     int retval;
  896.     /* Handle write differently depending on if its a socket or file descriptor */
  897.     if (!(out & WIN32_SOCKET_FLAG))
  898.       return write(out, buf, strlen (buf));
  900.     /* Socket */
  901.     retval = send (out & ~WIN32_SOCKET_FLAG, buf, strlen (buf), 0);
  903.     return retval != SOCKET_ERROR ? retval : -1;
  904.   }
  905. #endif
  906. }
  908. int fluid_server_socket_join(fluid_server_socket_t *server_socket)
  909. {
  910.   return fluid_thread_join (server_socket->thread);
  911. }
  914. #ifndef WIN32           // Not win32?
  916. #define SOCKET_ERROR -1
  918. fluid_istream_t fluid_socket_get_istream (fluid_socket_t sock)
  919. {
  920.   return sock;
  921. }
  923. fluid_ostream_t fluid_socket_get_ostream (fluid_socket_t sock)
  924. {
  925.   return sock;
  926. }
  928. void fluid_socket_close(fluid_socket_t sock)
  929. {
  930.   if (sock != INVALID_SOCKET)
  931.     close (sock);
  932. }
  934. static void
  935. fluid_server_socket_run (void *data)
  936. {
  937.   fluid_server_socket_t *server_socket = (fluid_server_socket_t *)data;
  938.   fluid_socket_t client_socket;
  939.   struct sockaddr_in addr;
  940.   socklen_t addrlen = sizeof (addr);
  941.   int retval;
  943.   FLUID_LOG (FLUID_DBG, "Server listening for connections");
  945.   while (server_socket->cont)
  946.   {
  947.     client_socket = accept (server_socket->socket, (struct sockaddr *)&addr, &addrlen);
  949.     FLUID_LOG (FLUID_DBG, "New client connection");
  951.     if (client_socket == INVALID_SOCKET)
  952.     {
  953.       if (server_socket->cont)
  954. FLUID_LOG(FLUID_ERR, "Failed to accept connection");
  956.       server_socket->cont = 0;
  957.       return;
  958.     } else {
  959.       retval = server_socket->func (server_socket->data, client_socket,
  960.                                     inet_ntoa (addr.sin_addr));  // FIXME - inet_ntoa is not thread safe
  962.       if (retval != 0)
  963. fluid_socket_close(client_socket);
  964.     }
  965.   }
  967.   FLUID_LOG(FLUID_DBG, "Server closing");
  968. }
  970. fluid_server_socket_t*
  971. new_fluid_server_socket(int port, fluid_server_func_t func, void* data)
  972. {
  973.   fluid_server_socket_t* server_socket;
  974.   struct sockaddr_in addr;
  975.   fluid_socket_t sock;
  977.   g_return_val_if_fail (func != NULL, NULL);
  979.   sock = socket(AF_INET, SOCK_STREAM, 0);
  980.   if (sock == INVALID_SOCKET) {
  981.     FLUID_LOG(FLUID_ERR, "Failed to create server socket");
  982.     return NULL;
  983.   }
  985.   FLUID_MEMSET((char *)&addr, 0, sizeof(struct sockaddr_in));
  986.   addr.sin_family = AF_INET;
  987.   addr.sin_addr.s_addr = htonl(INADDR_ANY);
  988.   addr.sin_port = htons(port);
  990.   if (bind(sock, (const struct sockaddr *) &addr, sizeof(struct sockaddr_in)) == SOCKET_ERROR) {
  991.     FLUID_LOG(FLUID_ERR, "Failed to bind server socket");
  992.     fluid_socket_close(sock);
  993.     return NULL;
  994.   }
  996.   if (listen(sock, 10) == SOCKET_ERROR) {
  997.     FLUID_LOG(FLUID_ERR, "Failed listen on server socket");
  998.     fluid_socket_close(sock);
  999.     return NULL;
  1000.   }
  1002.   server_socket = FLUID_NEW(fluid_server_socket_t);
  1003.   if (server_socket == NULL) {
  1004.     FLUID_LOG(FLUID_ERR, "Out of memory");
  1005.     fluid_socket_close(sock);
  1006.     return NULL;
  1007.   }
  1009.   server_socket->socket = sock;
  1010.   server_socket->func = func;
  1011.   server_socket->data = data;
  1012.   server_socket->cont = 1;
  1014.   server_socket->thread = new_fluid_thread(fluid_server_socket_run, server_socket,
  1015.                                            0, FALSE);
  1016.   if (server_socket->thread == NULL) {
  1017.     FLUID_FREE(server_socket);
  1018.     fluid_socket_close(sock);
  1019.     return NULL;
  1020.   }
  1022.   return server_socket;
  1023. }
  1025. int delete_fluid_server_socket(fluid_server_socket_t* server_socket)
  1026. {
  1027.   server_socket->cont = 0;
  1028.   if (server_socket->socket != INVALID_SOCKET) {
  1029.     fluid_socket_close(server_socket->socket);
  1030.   }
  1031.   if (server_socket->thread) {
  1032.     delete_fluid_thread(server_socket->thread);
  1033.   }
  1034.   FLUID_FREE(server_socket);
  1035.   return FLUID_OK;
  1036. }
  1039. #else           // Win32 is "special"
  1042. #ifndef WIN32_LEAN_AND_MEAN
  1043. #define WIN32_LEAN_AND_MEAN
  1044. #endif
  1046. fluid_istream_t fluid_socket_get_istream (fluid_socket_t sock)
  1047. {
  1048.   return sock | WIN32_SOCKET_FLAG;
  1049. }
  1051. fluid_ostream_t fluid_socket_get_ostream (fluid_socket_t sock)
  1052. {
  1053.   return sock | WIN32_SOCKET_FLAG;
  1054. }
  1056. void fluid_socket_close (fluid_socket_t sock)
  1057. {
  1058.   if (sock != INVALID_SOCKET)
  1059.     closesocket (sock);
  1060. }
  1062. static void fluid_server_socket_run (void *data)
  1063. {
  1064.   fluid_server_socket_t *server_socket = (fluid_server_socket_t *)data;
  1065.   fluid_socket_t client_socket;
  1066.   struct sockaddr_in addr;
  1067.   socklen_t addrlen = sizeof (addr);
  1068.   int r;
  1070.   FLUID_LOG(FLUID_DBG, "Server listening for connections");
  1072.   while (server_socket->cont)
  1073.   {
  1074.     client_socket = accept (server_socket->socket, (struct sockaddr *)&addr, &addrlen);
  1076.     FLUID_LOG (FLUID_DBG, "New client connection");
  1078.     if (client_socket == INVALID_SOCKET)
  1079.     {
  1080.       if (server_socket->cont)
  1081. FLUID_LOG (FLUID_ERR, "Failed to accept connection: %ld", WSAGetLastError ());
  1083.       server_socket->cont = 0;
  1084.       return;
  1085.     }
  1086.     else
  1087.     {
  1088.       r = server_socket->func (server_socket->data, client_socket,
  1089.                                inet_ntoa (addr.sin_addr));  // FIXME - inet_ntoa is not thread safe
  1090.       if (r != 0)
  1091. fluid_socket_close (client_socket);
  1092.     }
  1093.   }
  1095.   FLUID_LOG (FLUID_DBG, "Server closing");
  1096. }
  1098. fluid_server_socket_t*
  1099. new_fluid_server_socket(int port, fluid_server_func_t func, void* data)
  1100. {
  1101.   fluid_server_socket_t* server_socket;
  1102.   struct sockaddr_in addr;
  1103.   fluid_socket_t sock;
  1104.   WSADATA wsaData;
  1105.   int retval;
  1107.   g_return_val_if_fail (func != NULL, NULL);
  1109.   // Win32 requires initialization of winsock
  1110.   retval = WSAStartup (MAKEWORD (2,2), &wsaData);
  1112.   if (retval != 0)
  1113.   {
  1114.     FLUID_LOG(FLUID_ERR, "Server socket creation error: WSAStartup failed: %d", retval);
  1115.     return NULL;
  1116.   }
  1118.   sock = socket (AF_INET, SOCK_STREAM, 0);
  1120.   if (sock == INVALID_SOCKET)
  1121.   {
  1122.     FLUID_LOG (FLUID_ERR, "Failed to create server socket: %ld", WSAGetLastError ());
  1123.     WSACleanup ();
  1124.     return NULL;
  1125.   }
  1127.   addr.sin_family = AF_INET;
  1128.   addr.sin_port = htons (port);
  1129.   addr.sin_addr.s_addr = htonl (INADDR_ANY);
  1131.   retval = bind (sock, (struct sockaddr *)&addr, sizeof (addr));
  1133.   if (retval == SOCKET_ERROR)
  1134.   {
  1135.     FLUID_LOG (FLUID_ERR, "Failed to bind server socket: %ld", WSAGetLastError ());
  1136.     fluid_socket_close (sock);
  1137.     WSACleanup ();
  1138.     return NULL;
  1139.   }
  1141.   if (listen (sock, SOMAXCONN) == SOCKET_ERROR)
  1142.   {
  1143.     FLUID_LOG (FLUID_ERR, "Failed to listen on server socket: %ld", WSAGetLastError ());
  1144.     fluid_socket_close (sock);
  1145.     WSACleanup ();
  1146.     return NULL;
  1147.   }
  1149.   server_socket = FLUID_NEW (fluid_server_socket_t);
  1151.   if (server_socket == NULL)
  1152.   {
  1153.     FLUID_LOG (FLUID_ERR, "Out of memory");
  1154.     fluid_socket_close (sock);
  1155.     WSACleanup ();
  1156.     return NULL;
  1157.   }
  1159.   server_socket->socket = sock;
  1160.   server_socket->func = func;
  1161.   server_socket->data = data;
  1162.   server_socket->cont = 1;
  1164.   server_socket->thread = new_fluid_thread(fluid_server_socket_run, server_socket,
  1165.                                            0, FALSE);
  1166.   if (server_socket->thread == NULL)
  1167.   {
  1168.     FLUID_FREE (server_socket);
  1169.     fluid_socket_close (sock);
  1170.     WSACleanup ();
  1171.     return NULL;
  1172.   }
  1174.   return server_socket;
  1175. }
  1177. int delete_fluid_server_socket(fluid_server_socket_t *server_socket)
  1178. {
  1179.   server_socket->cont = 0;
  1181.   if (server_socket->socket != INVALID_SOCKET)
  1182.     fluid_socket_close (server_socket->socket);
  1184.   if (server_socket->thread)
  1185.     delete_fluid_thread (server_socket->thread);
  1187.   FLUID_FREE (server_socket);
  1189.   WSACleanup ();        // Should be called the same number of times as WSAStartup
  1191.   return FLUID_OK;
  1192. }
  1194. #endif