Non-ASCII characters not properly supported.
/GRTAGS
/GSYMS
/GTAGS
+/Debug
+/lib/Debug
+/clients/Debug
+*.suo
+*.sdf
+*.opensdf
+*.vcxproj.user
EXTRA_DIST=CHANGES.html README.streams BUGS \
README.upgrades.html README.client README.vhost README.developers \
-docs.css
+docs.css \
+disorder.sln
SUBDIRS=@subdirs@
DISTCHECK_CONFIGURE_FLAGS:=httpdir=$(distdir)/_inst/httpdir cgiexecdir=$(shell pwd)/$(distdir)/_inst/cgiexecdir
#
# This file is part of DisOrder.
-# Copyright (C) 2006-2009 Richard Kettlewell
+# Copyright (C) 2006-2009, 2011-2013 Richard Kettlewell
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
CLEANFILES=,commands ,completions \
*.gcda *.gcov *.gcno *.c.html index.html
-EXTRA_DIST=dump2wav
+EXTRA_DIST=dump2wav disorder.vcxproj disorder.vcxproj.filters
#include "log.h"
#include "queue.h"
#include "client.h"
-#include "wstat.h"
+#if !_WIN32
+# include "wstat.h"
+#endif
#include "table.h"
#include "charset.h"
#include "kvp.h"
#include "sink.h"
#include "mem.h"
#include "defs.h"
-#include "authorize.h"
+#if !_WIN32
+# include "authorize.h"
+#endif
#include "vector.h"
#include "version.h"
#include "dateparse.h"
if(q->scratched) xprintf(" scratched by %s\n",
nullcheck(utf82mb(q->scratched)));
else xprintf(" %s\n", playing_states[q->state]);
+#if _WIN32
+ if(q->wstat) xprintf(" %#x\n", q->wstat);
+#else
if(q->wstat) xprintf(" %s\n", wstat(q->wstat));
+#endif
}
static void cf_playing(char attribute((unused)) **argv) {
cf_somequeue(disorder_queue);
}
+#if _WIN32
+# define nl_langinfo(whatever) "ascii" /* hack */
+#endif
+
static void cf_quack(char attribute((unused)) **argv) {
if(!strcasecmp(nl_langinfo(CODESET), "utf-8")) {
#define TL "\xE2\x95\xAD"
return s[0] == '/';
}
+#if !_WIN32
static void cf_authorize(char **argv) {
authorize(getclient(), argv[0], argv[1]);
}
+#endif
static void cf_resolve(char **argv) {
char *track;
"Adopt a randomly picked track" },
{ "allfiles", 1, 2, cf_allfiles, isarg_regexp, "DIR [~REGEXP]",
"List all files and directories in DIR" },
+#if !_WIN32
{ "authorize", 1, 2, cf_authorize, isarg_rights, "USERNAME [RIGHTS]",
"Authorize user USERNAME to connect" },
+#endif
{ "deluser", 1, 1, cf_deluser, 0, "USERNAME",
"Delete user USERNAME" },
{ "dirs", 1, 2, cf_dirs, isarg_regexp, "DIR [~REGEXP]",
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup Label="ProjectConfigurations">
+ <ProjectConfiguration Include="Debug|Win32">
+ <Configuration>Debug</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|Win32">
+ <Configuration>Release</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ </ItemGroup>
+ <PropertyGroup Label="Globals">
+ <ProjectGuid>{FC369CF3-3F09-4053-82DC-739ECCFA514B}</ProjectGuid>
+ <Keyword>Win32Proj</Keyword>
+ <RootNamespace>disorder</RootNamespace>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+ <ConfigurationType>Application</ConfigurationType>
+ <UseDebugLibraries>true</UseDebugLibraries>
+ <PlatformToolset>v110</PlatformToolset>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+ <ConfigurationType>Application</ConfigurationType>
+ <UseDebugLibraries>false</UseDebugLibraries>
+ <PlatformToolset>v110</PlatformToolset>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+ <ImportGroup Label="ExtensionSettings">
+ </ImportGroup>
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <PropertyGroup Label="UserMacros" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <LinkIncremental>true</LinkIncremental>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <LinkIncremental>false</LinkIncremental>
+ </PropertyGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <ClCompile>
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ <WarningLevel>Level3</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <SDLCheck>false</SDLCheck>
+ <AdditionalIncludeDirectories>..\lib</AdditionalIncludeDirectories>
+ </ClCompile>
+ <Link>
+ <SubSystem>Console</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ </Link>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ <Optimization>MaxSpeed</Optimization>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <SDLCheck>false</SDLCheck>
+ </ClCompile>
+ <Link>
+ <SubSystem>Console</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <OptimizeReferences>true</OptimizeReferences>
+ </Link>
+ </ItemDefinitionGroup>
+ <ItemGroup>
+ <ClCompile Include="disorder.c" />
+ </ItemGroup>
+ <ItemGroup>
+ <ProjectReference Include="..\lib\lib.vcxproj">
+ <Project>{46e26f86-f1d2-40d1-b9dc-af844622d65d}</Project>
+ </ProjectReference>
+ </ItemGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+ <ImportGroup Label="ExtensionTargets">
+ </ImportGroup>
+</Project>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup>
+ <Filter Include="Source Files">
+ <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+ <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+ </Filter>
+ <Filter Include="Header Files">
+ <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+ <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+ </Filter>
+ <Filter Include="Resource Files">
+ <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+ <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+ </Filter>
+ </ItemGroup>
+ <ItemGroup>
+ <ClCompile Include="disorder.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ </ItemGroup>
+</Project>
\ No newline at end of file
--- /dev/null
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Express 2012 for Windows Desktop
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lib", "lib\lib.vcxproj", "{46E26F86-F1D2-40D1-B9DC-AF844622D65D}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "disorder", "clients\disorder.vcxproj", "{FC369CF3-3F09-4053-82DC-739ECCFA514B}"
+ ProjectSection(ProjectDependencies) = postProject
+ {46E26F86-F1D2-40D1-B9DC-AF844622D65D} = {46E26F86-F1D2-40D1-B9DC-AF844622D65D}
+ EndProjectSection
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Win32 = Debug|Win32
+ Release|Win32 = Release|Win32
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {46E26F86-F1D2-40D1-B9DC-AF844622D65D}.Debug|Win32.ActiveCfg = Debug|Win32
+ {46E26F86-F1D2-40D1-B9DC-AF844622D65D}.Debug|Win32.Build.0 = Debug|Win32
+ {46E26F86-F1D2-40D1-B9DC-AF844622D65D}.Release|Win32.ActiveCfg = Release|Win32
+ {46E26F86-F1D2-40D1-B9DC-AF844622D65D}.Release|Win32.Build.0 = Release|Win32
+ {FC369CF3-3F09-4053-82DC-739ECCFA514B}.Debug|Win32.ActiveCfg = Debug|Win32
+ {FC369CF3-3F09-4053-82DC-739ECCFA514B}.Debug|Win32.Build.0 = Debug|Win32
+ {FC369CF3-3F09-4053-82DC-739ECCFA514B}.Release|Win32.ActiveCfg = Release|Win32
+ {FC369CF3-3F09-4053-82DC-739ECCFA514B}.Release|Win32.Build.0 = Release|Win32
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
CLEANFILES=definitions.h definitions.h.new version-string versionstring.h \
*.gcda *.gcov *.gcno *.c.html index.html
-EXTRA_DIST=trackdb.c trackdb-stub.c client-stubs.c eclient-stubs.c
+EXTRA_DIST=trackdb.c trackdb-stub.c client-stubs.c eclient-stubs.c \
+ getopt.c getopt.h getopt1.c \
+ disorder-win32.c disorder-win32.h \
+ lib.vcxproj lib.vcxproj.filters
#if HAVE_SYS_UN_H
# include <sys/un.h>
#endif
+#if HAVE_WS2TCPIP_H
+# include <Ws2tcpip.h>
+#endif
#include "log.h"
#include "printf.h"
if(sin4->sin_port)
byte_xasprintf(&r, "%s port %u",
- inet_ntop(sin4->sin_family, &sin4->sin_addr,
+ inet_ntop(sin4->sin_family, (void *)&sin4->sin_addr,
buffer, sizeof buffer),
ntohs(sin4->sin_port));
else
byte_xasprintf(&r, "%s",
- inet_ntop(sin4->sin_family, &sin4->sin_addr,
+ inet_ntop(sin4->sin_family, (void *)&sin4->sin_addr,
buffer, sizeof buffer));
return r;
}
if(sin6->sin6_port)
byte_xasprintf(&r, "%s port %u",
- inet_ntop(sin6->sin6_family, &sin6->sin6_addr,
+ inet_ntop(sin6->sin6_family, (void *)&sin6->sin6_addr,
buffer, sizeof buffer),
ntohs(sin6->sin6_port));
else
byte_xasprintf(&r, "%s",
- inet_ntop(sin6->sin6_family, &sin6->sin6_addr,
+ inet_ntop(sin6->sin6_family, (void *)&sin6->sin6_addr,
buffer, sizeof buffer));
return r;
}
#include <stddef.h>
#if HAVE_GCRYPT_H
# include <gcrypt.h>
+#elif HAVE_BCRYPT_H
+# include <bcrypt.h>
+# pragma comment(lib, "bcrypt")
#else
# error No crypto API available
#endif
#include "hex.h"
#include "log.h"
#include "authhash.h"
+#include "vector.h"
/** @brief Structure of algorithm lookup table */
struct algorithm {
#if HAVE_GCRYPT_H
/** @brief gcrypt algorithm ID */
int id;
+#elif HAVE_BCRYPT_H
+ /** @brief CNG algorithm ID */
+ const wchar_t *id;
#endif
};
{ "sha384", GCRY_MD_SHA384 },
{ "SHA512", GCRY_MD_SHA512 },
{ "sha512", GCRY_MD_SHA512 },
+#elif HAVE_BCRYPT_H
+ { "SHA1", BCRYPT_SHA1_ALGORITHM },
+ { "sha1", BCRYPT_SHA1_ALGORITHM },
+ { "SHA256", BCRYPT_SHA256_ALGORITHM },
+ { "sha256", BCRYPT_SHA256_ALGORITHM },
+ { "SHA384", BCRYPT_SHA384_ALGORITHM },
+ { "sha384", BCRYPT_SHA384_ALGORITHM },
+ { "SHA512", BCRYPT_SHA512_ALGORITHM },
+ { "sha512", BCRYPT_SHA512_ALGORITHM },
#endif
};
#if HAVE_GCRYPT_H
gcrypt_hash_handle h;
int id;
+#elif HAVE_BCRYPT_H
+ BCRYPT_ALG_HANDLE alg = 0;
+ BCRYPT_HASH_HANDLE hash = 0;
+ DWORD hashlen, hashlenlen;
+ PBYTE hashed = 0;
+ NTSTATUS rc;
+ struct dynstr d;
#endif
char *res;
size_t n;
gcry_md_write(h, challenge, nchallenge);
res = hex(gcry_md_read(h, id), gcry_md_get_algo_dlen(id));
gcry_md_close(h);
+#elif HAVE_BCRYPT_H
+ dynstr_init(&d);
+ dynstr_append_string(&d, password);
+ dynstr_append_bytes(&d, challenge, nchallenge);
+#define DO(fn, args) do { \
+ if((rc = fn args)) { disorder_error(0, "%s: %d", #fn, rc); goto error; } \
+ } while(0)
+ res = NULL;
+ DO(BCryptOpenAlgorithmProvider, (&alg, algorithms[n].id, NULL, 0));
+ DO(BCryptGetProperty, (alg, BCRYPT_HASH_LENGTH, (PBYTE)&hashlen, sizeof hashlen, &hashlenlen, 0));
+ DO(BCryptCreateHash, (alg, &hash, NULL, 0, NULL, 0, 0));
+ DO(BCryptHashData, (hash, d.vec, d.nvec, 0));
+ hashed = xmalloc(hashlen);
+ DO(BCryptFinishHash, (hash, hashed, hashlen, 0));
+ res = hex(hashed, hashlen);
+error:
+ if(hash) BCryptDestroyHash(hash);
+ if(alg) BCryptCloseAlgorithmProvider(alg, 0);
+ xfree(hashed);
#endif
return res;
}
#include "vector.h"
#include "unicode.h"
+#if _WIN32
+// TODO WIN32 we assume UTF-8 here, which is *definitely wrong*
+char *mb2utf8(const char *mb) {
+ return xstrdup(mb);
+}
+
+char *utf82mb(const char *utf8) {
+ return xstrdup(utf8);
+}
+#else
+
/** @brief Low-level converstion routine
* @param from Source encoding
* @param to Destination encoding
else return xstrdup(any);
}
+#endif
+
/** @brief Truncate a string for display purposes
* @param s Pointer to UTF-8 string
* @param max Maximum number of columns
return s;
}
+#if !_WIN32
char *any2utf8_f(const char *from,
char *any) {
char *s = any2utf8(from, any);
xfree(any);
return s;
}
+#endif
/*
Local Variables:
#if HAVE_UNISTD_H
# include <unistd.h>
#endif
+#if HAVE_WS2TCPIP_H
+# include <Ws2tcpip.h>
+#endif
#include "log.h"
#include "configuration.h"
socklen_t find_server(struct config *c,
struct sockaddr **sap, char **namep) {
struct sockaddr *sa;
+#if !_WIN32
struct sockaddr_un su;
+#endif
struct addrinfo *res = 0;
char *name = NULL;
socklen_t len;
sa = res->ai_addr;
len = res->ai_addrlen;
} else {
+#if _WIN32
+ disorder_fatal(0, "local connections are not supported on Windows");
+#else
/* use the private socket if possible (which it should be) */
name = config_get_file2(c, "private/socket");
if(access(name, R_OK) != 0) {
sa = (struct sockaddr *)&su;
len = sizeof su;
xfree(name);
+#endif
}
*sap = xmalloc_noptr(len);
memcpy(*sap, sa, len);
return 0;
}
+#if _WIN32
+# define boolean bodge_boolean
+#endif
+
/** @brief Parse a boolean response
* @param cmd Command for use in error messsage
* @param value Result from server
byte_xasprintf((char **)&c->last, "input error: unexpected EOF");
return -1;
}
+
return 0;
}
# include <config.h>
#endif
+#if _WIN32
+# include "disorder-win32.h"
+#else
# define SOCKET int
# define INVALID_SOCKET (-1)
# define declspec(x)
# define socket_error() (errno)
# define system_error() (errno)
# define network_init()
+#endif
#if HAVE_INTTYPES_H
# include <inttypes.h>
#if HAVE_PCRE_H
# include <pcre.h>
#endif
+#if HAVE_SHLOBJ_H
+# include <Shlobj.h>
+#endif
#include <signal.h>
#include "rights.h"
#include "signame.h"
#include "authhash.h"
#include "vector.h"
+#if !_WIN32
#include "uaudio.h"
+#endif
/** @brief Path to config file
*
*/
int config_per_user = 1;
+#if !_WIN32
/** @brief Table of audio APIs
*
* Only set in server processes.
*/
const struct uaudio *const *config_uaudio_apis;
+#endif
/** @brief Config file parser state */
struct config_state {
cs->path, cs->line, t);
return -1;
}
- if(format) format->bits = t;
+ if(format) format->bits = (uint8_t)t;
switch (*p) {
case 'l': case 'L': t = ENDIAN_LITTLE; p++; break;
case 'b': case 'B': t = ENDIAN_BIG; p++; break;
default: t = ENDIAN_NATIVE; break;
}
- if(format) format->endian = t;
+ if(format) format->endian = (uint8_t)t;
if(*p != '/') {
disorder_error(errno, "%s:%d: expected `/' after bits-per-sample",
cs->path, cs->line);
cs->path, cs->line, t);
return -1;
}
- if(format) format->channels = t;
+ if(format) format->channels = (uint8_t)t;
if(*p) {
disorder_error(0, "%s:%d: junk after channels", cs->path, cs->line);
return -1;
return 0;
}
+#if !_WIN32
/** @brief Validate a system username
* @param cs Configuration state
* @param nvec Length of (proposed) new value
}
return 0;
}
+#endif
/** @brief Validate a sample format string
* @param cs Configuration state
return 0;
}
+#if !_WIN32
/** @brief Validate a playback backend name
* @param cs Configuration state
* @param nvec Length of (proposed) new value
/* In non-server processes we have no idea what's valid */
return 0;
}
+#endif
/** @brief Validate a pause mode string
* @param cs Configuration state
/** @brief All configuration items */
static const struct conf conf[] = {
{ C(alias), &type_string, validate_alias },
+#if !_WIN32
{ C(api), &type_string, validate_backend },
+#endif
{ C(authorization_algorithm), &type_string, validate_algo },
{ C(broadcast), &type_netaddress, validate_destaddr },
{ C(broadcast_from), &type_netaddress, validate_any },
{ C(default_rights), &type_rights, validate_any },
{ C(device), &type_string, validate_any },
{ C(history), &type_integer, validate_positive },
+#if !_WIN32
{ C(home), &type_string, validate_isabspath },
+#endif
{ C(listen), &type_netaddress, validate_any },
{ C(mail_sender), &type_string, validate_any },
{ C(mixer), &type_string, validate_any },
{ C(rtp_verbose), &type_boolean, validate_any },
{ C(sample_format), &type_sample_format, validate_sample_format },
{ C(scratch), &type_string_accum, validate_isreg },
+#if !_WIN32
{ C(sendmail), &type_string, validate_isabspath },
+#endif
{ C(short_display), &type_integer, validate_positive },
{ C(signal), &type_signal, validate_any },
{ C(smtp_server), &type_string, validate_any },
{ C(sox_generation), &type_integer, validate_non_negative },
+#if !_WIN32
{ C2(speaker_backend, api), &type_string, validate_backend },
+#endif
{ C(speaker_command), &type_string, validate_any },
{ C(stopword), &type_string_accum, validate_any },
{ C(templates), &type_string_accum, validate_isdir },
{ C(transform), &type_transform, validate_any },
#endif
{ C(url), &type_string, validate_url },
+#if !_WIN32
{ C(user), &type_string, validate_isauser },
+#endif
{ C(username), &type_string, validate_any },
};
*/
static struct config *config_default(void) {
struct config *c = xmalloc(sizeof *c);
+#if !_WIN32
const char *logname;
struct passwd *pw;
+#endif
struct config_state cs;
size_t n;
cs.config = c;
/* Strings had better be xstrdup'd as they will get freed at some point. */
c->history = 60;
+#if !_WIN32
c->home = xstrdup(pkgstatedir);
+#endif
+#if _WIN32
+ {
+ char buffer[128];
+ DWORD bufsize = sizeof buffer;
+ if(!GetUserNameA(buffer, &bufsize))
+ disorder_fatal(0, "cannot determine our username");
+ c->username = xstrdup(buffer);
+ }
+#else
if(!(pw = getpwuid(getuid())))
disorder_fatal(0, "cannot determine our username");
logname = pw->pw_name;
c->username = xstrdup(logname);
+#endif
c->refresh = 15;
c->refresh_min = 1;
+#ifdef SIGKILL
c->signal = SIGKILL;
+#else
+ c->signal = SIGTERM;
+#endif
c->alias = xstrdup("{/artist}{/album}{/title}{ext}");
c->device = xstrdup("default");
c->nice_rescan = 10;
c->dbversion = 2;
c->cookie_login_lifetime = 86400;
c->cookie_key_lifetime = 86400 * 7;
+#if !_WIN32
if(sendmail_binary[0] && strcmp(sendmail_binary, "none"))
c->sendmail = xstrdup(sendmail_binary);
+#endif
c->smtp_server = xstrdup("127.0.0.1");
c->new_max = 100;
c->reminder_interval = 600; /* 10m */
return c;
}
+#if !_WIN32
/** @brief Construct a filename
* @param c Configuration
* @param name Base filename
byte_xasprintf(&s, "%s/%s", c->home, name);
return s;
}
+#endif
/** @brief Set the default configuration file */
static void set_configfile(void) {
+#if !_WIN32
if(!configfile)
byte_xasprintf(&configfile, "%s/config", pkgconfdir);
+#endif
}
/** @brief Free a configuration object
c->api = xstrdup("command");
else if(c->broadcast.af != -1)
c->api = xstrdup("rtp");
+#if !_WIN32
else if(config_uaudio_apis)
c->api = xstrdup(uaudio_default(config_uaudio_apis,
UAUDIO_API_SERVER)->name);
+#endif
else
c->api = xstrdup("<none>");
}
const struct config *oldconfig) {
struct config *c;
char *privconf;
- struct passwd *pw;
+ struct passwd *pw = NULL;
set_configfile();
c = config_default();
- /* standalone Disobedience installs might not have a global config file */
- if(access(configfile, F_OK) == 0)
- if(config_include(c, configfile))
- return -1;
+ /* standalone client installs might not have a global config file */
+ if(configfile)
+ if(access(configfile, F_OK) == 0)
+ if(config_include(c, configfile))
+ return -1;
/* if we can read the private config file, do */
if((privconf = config_private())
&& access(privconf, R_OK) == 0
xfree(privconf);
/* if there's a per-user system config file for this user, read it */
if(config_per_user) {
+#if !_WIN32
if(!(pw = getpwuid(getuid())))
disorder_fatal(0, "cannot determine our username");
if((privconf = config_usersysconf(pw))
&& config_include(c, privconf))
return -1;
xfree(privconf);
+#endif
/* if we have a password file, read it */
if((privconf = config_userconf(0, pw))
&& access(privconf, F_OK) == 0
config_postdefaults(c, server);
if(oldconfig) {
int failed = 0;
+#if !_WIN32
if(strcmp(c->home, oldconfig->home)) {
disorder_error(0, "'home' cannot be changed without a restart");
failed = 1;
}
+#endif
if(strcmp(c->alias, oldconfig->alias)) {
disorder_error(0, "'alias' cannot be changed without a restart");
failed = 1;
/** @brief Return the path to the private configuration file */
char *config_private(void) {
+#if _WIN32
+ return NULL;
+#else
char *s;
set_configfile();
byte_xasprintf(&s, "%s.private", configfile);
return s;
+#endif
}
/** @brief Return the path to user's personal configuration file */
char *config_userconf(const char *home, const struct passwd *pw) {
char *s;
-
+#if _WIN32
+ wchar_t *wpath = 0;
+ char *appdata;
+ if(SHGetKnownFolderPath(&FOLDERID_RoamingAppData, 0, NULL, &wpath) != S_OK)
+ disorder_fatal(0, "error calling SHGetKnownFolderPath");
+ appdata = win_wtomb(wpath);
+ CoTaskMemFree(wpath);
+ byte_xasprintf(&s, "%s\\DisOrder\\passwd", appdata);
+#else
if(!home && !pw && !(pw = getpwuid(getuid())))
disorder_fatal(0, "cannot determine our username");
byte_xasprintf(&s, "%s/.disorder/passwd", home ? home : pw->pw_dir);
+#endif
return s;
}
+#if !_WIN32
/** @brief Return the path to user-specific system configuration */
char *config_usersysconf(const struct passwd *pw) {
char *s;
char *config_get_file(const char *name) {
return config_get_file2(config, name);
}
+#endif
/** @brief Order two stringlists
* @param a First stringlist
/** @brief Maximum lifetime of a playlist lock */
long playlist_lock_timeout;
+#if !_WIN32
/** @brief Home directory for state files */
const char *home;
+#endif
/** @brief Login username */
char *username;
#ifndef DEFS_H
#define DEFS_H
-extern const char disorder_short_version_string[];
extern const char disorder_version_string[];
+#if !_WIN32
+extern const char disorder_short_version_string[];
extern const char pkglibdir[];
extern const char pkgconfdir[];
extern const char pkgstatedir[];
extern const char sbindir[];
extern const char finkbindir[];
extern const char sendmail_binary[];
+#endif
#endif /* DEFS_H */
--- /dev/null
+/*
+ * This file is part of DisOrder.
+ * Copyright (C) 2013 Richard Kettlewell
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+/** @file lib/disorder-win32.c
+ * @brief Windows support
+ */
+#include "common.h"
+#include "mem.h"
+#include "log.h"
+#include "vector.h"
+
+int gettimeofday(struct timeval *tv, struct timezone *tz) {
+ FILETIME ft;
+ unsigned long long cns;
+ GetSystemTimeAsFileTime(&ft);
+ cns = ((unsigned long long)ft.dwHighDateTime << 32) + ft.dwLowDateTime;
+ /* This gives the count of 100ns intervals since the start of 1601.
+ * WP thinks that this is interpreted according to the proleptic Gregorian
+ * calendar though MS do not say.
+ */
+ tv->tv_usec = (cns % 10000000) / 10;
+ tv->tv_sec = (long)(cns / 10000000 - 86400LL * ((1970 - 1601) * 365
+ + (1970 - 1601) / 4
+ - (1970 - 1601) / 100));
+ return 0;
+}
+
+char *win_wtomb(const wchar_t *ws) {
+ char *s;
+ size_t converted;
+ int rc;
+ if((rc = wcstombs_s(&converted, NULL, 0, ws, 0)))
+ disorder_fatal(rc, "wcstombs_s");
+ s = xmalloc(converted);
+ if((rc = wcstombs_s(&converted, s, converted, ws, converted)))
+ disorder_fatal(rc, "wcstombs_s");
+ return s;
+}
+
+void network_init(void) {
+ WSADATA wsadata;
+ int rc;
+ if((rc = WSAStartup(MAKEWORD(2, 2), &wsadata)))
+ disorder_fatal(0, "WSAStartup: %d", rc);
+}
\ No newline at end of file
--- /dev/null
+/*
+ * This file is part of DisOrder.
+ * Copyright (C) 2013 Richard Kettlewell
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+/** @file lib/disorder-win32.h
+ * @brief Windows support
+ */
+#ifndef DISORDER_WIN32_H
+# define DISORDER_WIN32_H
+
+#define HAVE_WS2TCPIP_H 1
+#define HAVE_SHLOBJ_H 1
+#define HAVE_BCRYPT_H 1
+#define HAVE_CLOSESOCKET 1
+
+#include <WinSock2.h>
+#include <io.h>
+
+#define access _access /* quieten compiler */
+
+#include <time.h>
+
+#define attribute(x) /* nothing */
+#define declspec(x) __declspec(x)
+#define inline __inline
+#define DEFAULT_SOX_GENERATION 1
+#define F_OK 0
+#define W_OK 2
+#define R_OK 4
+#define LOG_EMERG 0
+#define LOG_ALERT 1
+#define LOG_CRIT 2
+#define LOG_ERR 3
+#define LOG_WARNING 4
+#define LOG_NOTICE 5
+#define LOG_INFO 6
+#define LOG_DEBUG 7
+#define S_ISREG(mode) ((mode) & _S_IFREG)
+#define S_ISDIR(mode) ((mode) & _S_IFDIR)
+#define strcasecmp _stricmp
+
+#ifdef _WIN64
+typedef long long ssize_t;
+#else
+typedef long ssize_t;
+#endif
+typedef int socklen_t;
+typedef long long int64_t;
+typedef unsigned long long uint64_t;
+typedef int pid_t;
+
+struct timezone;
+
+int gettimeofday(struct timeval *tv, struct timezone *tz);
+char *win_wtomb(const wchar_t *ws);
+void network_init(void);
+
+#define socket_error() (WSAGetLastError())
+#define system_error() (GetLastError())
+
+#pragma comment(lib, "Ws2_32.lib")
+
+#endif
\ No newline at end of file
--- /dev/null
+/* Getopt for GNU.
+ NOTE: getopt is now part of the C library, so if you don't know what
+ "Keep this file name-space clean" means, talk to drepper@gnu.org
+ before changing it!
+
+ Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
+ Free Software Foundation, Inc.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+\f
+/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
+ Ditto for AIX 3.2 and <stdlib.h>. */
+#ifndef _NO_PROTO
+# define _NO_PROTO
+#endif
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#if _WIN32
+# define HAVE_STRING_H 1
+#endif
+
+#if !defined __STDC__ || !__STDC__
+/* This is a separate conditional since some stdc systems
+ reject `defined (const)'. */
+# ifndef const
+# define const
+# endif
+#endif
+
+#include <stdio.h>
+
+/* Comment out all this code if we are using the GNU C Library, and are not
+ actually compiling the library itself. This code is part of the GNU C
+ Library, but also included in many other GNU distributions. Compiling
+ and linking in this code is a waste when using the GNU C library
+ (especially if it is a shared library). Rather than having every GNU
+ program understand `configure --with-gnu-libc' and omit the object files,
+ it is simpler to just do this in the source for each such file. */
+
+#define GETOPT_INTERFACE_VERSION 2
+#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
+# include <gnu-versions.h>
+# if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
+# define ELIDE_CODE
+# endif
+#endif
+
+#ifndef ELIDE_CODE
+
+
+/* This needs to come after some library #include
+ to get __GNU_LIBRARY__ defined. */
+#ifdef __GNU_LIBRARY__
+/* Don't include stdlib.h for non-GNU C libraries because some of them
+ contain conflicting prototypes for getopt. */
+# include <stdlib.h>
+# include <unistd.h>
+#endif /* GNU C library. */
+
+#ifdef VMS
+# include <unixlib.h>
+# if HAVE_STRING_H - 0
+# include <string.h>
+# endif
+#endif
+
+#ifndef _
+/* This is for other GNU distributions with internationalized messages.
+ When compiling libc, the _ macro is predefined. */
+# ifdef HAVE_LIBINTL_H
+# include <libintl.h>
+# define _(msgid) gettext (msgid)
+# else
+# define _(msgid) (msgid)
+# endif
+#endif
+
+/* This version of `getopt' appears to the caller like standard Unix `getopt'
+ but it behaves differently for the user, since it allows the user
+ to intersperse the options with the other arguments.
+
+ As `getopt' works, it permutes the elements of ARGV so that,
+ when it is done, all the options precede everything else. Thus
+ all application programs are extended to handle flexible argument order.
+
+ Setting the environment variable POSIXLY_CORRECT disables permutation.
+ Then the behavior is completely standard.
+
+ GNU application programs can use a third alternative mode in which
+ they can distinguish the relative order of options and other arguments. */
+
+#include "getopt.h"
+
+/* For communication from `getopt' to the caller.
+ When `getopt' finds an option that takes an argument,
+ the argument value is returned here.
+ Also, when `ordering' is RETURN_IN_ORDER,
+ each non-option ARGV-element is returned here. */
+
+char *optarg;
+
+/* Index in ARGV of the next element to be scanned.
+ This is used for communication to and from the caller
+ and for communication between successive calls to `getopt'.
+
+ On entry to `getopt', zero means this is the first call; initialize.
+
+ When `getopt' returns -1, this is the index of the first of the
+ non-option elements that the caller should itself scan.
+
+ Otherwise, `optind' communicates from one call to the next
+ how much of ARGV has been scanned so far. */
+
+/* 1003.2 says this must be 1 before any call. */
+int optind = 1;
+
+/* Formerly, initialization of getopt depended on optind==0, which
+ causes problems with re-calling getopt as programs generally don't
+ know that. */
+
+int __getopt_initialized;
+
+/* The next char to be scanned in the option-element
+ in which the last option character we returned was found.
+ This allows us to pick up the scan where we left off.
+
+ If this is zero, or a null string, it means resume the scan
+ by advancing to the next ARGV-element. */
+
+static char *nextchar;
+
+/* Callers store zero here to inhibit the error message
+ for unrecognized options. */
+
+int opterr = 1;
+
+/* Set to an option character which was unrecognized.
+ This must be initialized on some systems to avoid linking in the
+ system's own getopt implementation. */
+
+int optopt = '?';
+
+/* Describe how to deal with options that follow non-option ARGV-elements.
+
+ If the caller did not specify anything,
+ the default is REQUIRE_ORDER if the environment variable
+ POSIXLY_CORRECT is defined, PERMUTE otherwise.
+
+ REQUIRE_ORDER means don't recognize them as options;
+ stop option processing when the first non-option is seen.
+ This is what Unix does.
+ This mode of operation is selected by either setting the environment
+ variable POSIXLY_CORRECT, or using `+' as the first character
+ of the list of option characters.
+
+ PERMUTE is the default. We permute the contents of ARGV as we scan,
+ so that eventually all the non-options are at the end. This allows options
+ to be given in any order, even with programs that were not written to
+ expect this.
+
+ RETURN_IN_ORDER is an option available to programs that were written
+ to expect options and other ARGV-elements in any order and that care about
+ the ordering of the two. We describe each non-option ARGV-element
+ as if it were the argument of an option with character code 1.
+ Using `-' as the first character of the list of option characters
+ selects this mode of operation.
+
+ The special argument `--' forces an end of option-scanning regardless
+ of the value of `ordering'. In the case of RETURN_IN_ORDER, only
+ `--' can cause `getopt' to return -1 with `optind' != ARGC. */
+
+static enum
+{
+ REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
+} ordering;
+
+/* Value of POSIXLY_CORRECT environment variable. */
+static char *posixly_correct;
+\f
+#ifdef __GNU_LIBRARY__
+/* We want to avoid inclusion of string.h with non-GNU libraries
+ because there are many ways it can cause trouble.
+ On some systems, it contains special magic macros that don't work
+ in GCC. */
+# include <string.h>
+# define my_index strchr
+#else
+
+# if HAVE_STRING_H
+# include <string.h>
+# else
+# include <strings.h>
+# endif
+
+/* Avoid depending on library functions or files
+ whose names are inconsistent. */
+
+#ifndef getenv
+extern char *getenv ();
+#endif
+
+static char *
+my_index (str, chr)
+ const char *str;
+ int chr;
+{
+ while (*str)
+ {
+ if (*str == chr)
+ return (char *) str;
+ str++;
+ }
+ return 0;
+}
+
+/* If using GCC, we can safely declare strlen this way.
+ If not using GCC, it is ok not to declare it. */
+#ifdef __GNUC__
+/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
+ That was relevant to code that was here before. */
+# if (!defined __STDC__ || !__STDC__) && !defined strlen
+/* gcc with -traditional declares the built-in strlen to return int,
+ and has done so at least since version 2.4.5. -- rms. */
+extern int strlen (const char *);
+# endif /* not __STDC__ */
+#endif /* __GNUC__ */
+
+#endif /* not __GNU_LIBRARY__ */
+\f
+/* Handle permutation of arguments. */
+
+/* Describe the part of ARGV that contains non-options that have
+ been skipped. `first_nonopt' is the index in ARGV of the first of them;
+ `last_nonopt' is the index after the last of them. */
+
+static int first_nonopt;
+static int last_nonopt;
+
+#ifdef _LIBC
+/* Bash 2.0 gives us an environment variable containing flags
+ indicating ARGV elements that should not be considered arguments. */
+
+/* Defined in getopt_init.c */
+extern char *__getopt_nonoption_flags;
+
+static int nonoption_flags_max_len;
+static int nonoption_flags_len;
+
+static int original_argc;
+static char *const *original_argv;
+
+/* Make sure the environment variable bash 2.0 puts in the environment
+ is valid for the getopt call we must make sure that the ARGV passed
+ to getopt is that one passed to the process. */
+static void
+__attribute__ ((unused))
+store_args_and_env (int argc, char *const *argv)
+{
+ /* XXX This is no good solution. We should rather copy the args so
+ that we can compare them later. But we must not use malloc(3). */
+ original_argc = argc;
+ original_argv = argv;
+}
+# ifdef text_set_element
+text_set_element (__libc_subinit, store_args_and_env);
+# endif /* text_set_element */
+
+# define SWAP_FLAGS(ch1, ch2) \
+ if (nonoption_flags_len > 0) \
+ { \
+ char __tmp = __getopt_nonoption_flags[ch1]; \
+ __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \
+ __getopt_nonoption_flags[ch2] = __tmp; \
+ }
+#else /* !_LIBC */
+# define SWAP_FLAGS(ch1, ch2)
+#endif /* _LIBC */
+
+/* Exchange two adjacent subsequences of ARGV.
+ One subsequence is elements [first_nonopt,last_nonopt)
+ which contains all the non-options that have been skipped so far.
+ The other is elements [last_nonopt,optind), which contains all
+ the options processed since those non-options were skipped.
+
+ `first_nonopt' and `last_nonopt' are relocated so that they describe
+ the new indices of the non-options in ARGV after they are moved. */
+
+#if defined __STDC__ && __STDC__
+static void exchange (char **);
+#endif
+
+static void
+exchange (argv)
+ char **argv;
+{
+ int bottom = first_nonopt;
+ int middle = last_nonopt;
+ int top = optind;
+ char *tem;
+
+ /* Exchange the shorter segment with the far end of the longer segment.
+ That puts the shorter segment into the right place.
+ It leaves the longer segment in the right place overall,
+ but it consists of two parts that need to be swapped next. */
+
+#ifdef _LIBC
+ /* First make sure the handling of the `__getopt_nonoption_flags'
+ string can work normally. Our top argument must be in the range
+ of the string. */
+ if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
+ {
+ /* We must extend the array. The user plays games with us and
+ presents new arguments. */
+ char *new_str = malloc (top + 1);
+ if (new_str == NULL)
+ nonoption_flags_len = nonoption_flags_max_len = 0;
+ else
+ {
+ memset (__mempcpy (new_str, __getopt_nonoption_flags,
+ nonoption_flags_max_len),
+ '\0', top + 1 - nonoption_flags_max_len);
+ nonoption_flags_max_len = top + 1;
+ __getopt_nonoption_flags = new_str;
+ }
+ }
+#endif
+
+ while (top > middle && middle > bottom)
+ {
+ if (top - middle > middle - bottom)
+ {
+ /* Bottom segment is the short one. */
+ int len = middle - bottom;
+ register int i;
+
+ /* Swap it with the top part of the top segment. */
+ for (i = 0; i < len; i++)
+ {
+ tem = argv[bottom + i];
+ argv[bottom + i] = argv[top - (middle - bottom) + i];
+ argv[top - (middle - bottom) + i] = tem;
+ SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
+ }
+ /* Exclude the moved bottom segment from further swapping. */
+ top -= len;
+ }
+ else
+ {
+ /* Top segment is the short one. */
+ int len = top - middle;
+ register int i;
+
+ /* Swap it with the bottom part of the bottom segment. */
+ for (i = 0; i < len; i++)
+ {
+ tem = argv[bottom + i];
+ argv[bottom + i] = argv[middle + i];
+ argv[middle + i] = tem;
+ SWAP_FLAGS (bottom + i, middle + i);
+ }
+ /* Exclude the moved top segment from further swapping. */
+ bottom += len;
+ }
+ }
+
+ /* Update records for the slots the non-options now occupy. */
+
+ first_nonopt += (optind - last_nonopt);
+ last_nonopt = optind;
+}
+
+/* Initialize the internal data when the first call is made. */
+
+#if defined __STDC__ && __STDC__
+static const char *_getopt_initialize (int, char *const *, const char *);
+#endif
+static const char *
+_getopt_initialize (argc, argv, optstring)
+ int argc;
+ char *const *argv;
+ const char *optstring;
+{
+ /* Start processing options with ARGV-element 1 (since ARGV-element 0
+ is the program name); the sequence of previously skipped
+ non-option ARGV-elements is empty. */
+
+ first_nonopt = last_nonopt = optind;
+
+ nextchar = NULL;
+
+ posixly_correct = getenv ("POSIXLY_CORRECT");
+
+ /* Determine how to handle the ordering of options and nonoptions. */
+
+ if (optstring[0] == '-')
+ {
+ ordering = RETURN_IN_ORDER;
+ ++optstring;
+ }
+ else if (optstring[0] == '+')
+ {
+ ordering = REQUIRE_ORDER;
+ ++optstring;
+ }
+ else if (posixly_correct != NULL)
+ ordering = REQUIRE_ORDER;
+ else
+ ordering = PERMUTE;
+
+#ifdef _LIBC
+ if (posixly_correct == NULL
+ && argc == original_argc && argv == original_argv)
+ {
+ if (nonoption_flags_max_len == 0)
+ {
+ if (__getopt_nonoption_flags == NULL
+ || __getopt_nonoption_flags[0] == '\0')
+ nonoption_flags_max_len = -1;
+ else
+ {
+ const char *orig_str = __getopt_nonoption_flags;
+ int len = nonoption_flags_max_len = strlen (orig_str);
+ if (nonoption_flags_max_len < argc)
+ nonoption_flags_max_len = argc;
+ __getopt_nonoption_flags =
+ (char *) malloc (nonoption_flags_max_len);
+ if (__getopt_nonoption_flags == NULL)
+ nonoption_flags_max_len = -1;
+ else
+ memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
+ '\0', nonoption_flags_max_len - len);
+ }
+ }
+ nonoption_flags_len = nonoption_flags_max_len;
+ }
+ else
+ nonoption_flags_len = 0;
+#endif
+
+ return optstring;
+}
+\f
+/* Scan elements of ARGV (whose length is ARGC) for option characters
+ given in OPTSTRING.
+
+ If an element of ARGV starts with '-', and is not exactly "-" or "--",
+ then it is an option element. The characters of this element
+ (aside from the initial '-') are option characters. If `getopt'
+ is called repeatedly, it returns successively each of the option characters
+ from each of the option elements.
+
+ If `getopt' finds another option character, it returns that character,
+ updating `optind' and `nextchar' so that the next call to `getopt' can
+ resume the scan with the following option character or ARGV-element.
+
+ If there are no more option characters, `getopt' returns -1.
+ Then `optind' is the index in ARGV of the first ARGV-element
+ that is not an option. (The ARGV-elements have been permuted
+ so that those that are not options now come last.)
+
+ OPTSTRING is a string containing the legitimate option characters.
+ If an option character is seen that is not listed in OPTSTRING,
+ return '?' after printing an error message. If you set `opterr' to
+ zero, the error message is suppressed but we still return '?'.
+
+ If a char in OPTSTRING is followed by a colon, that means it wants an arg,
+ so the following text in the same ARGV-element, or the text of the following
+ ARGV-element, is returned in `optarg'. Two colons mean an option that
+ wants an optional arg; if there is text in the current ARGV-element,
+ it is returned in `optarg', otherwise `optarg' is set to zero.
+
+ If OPTSTRING starts with `-' or `+', it requests different methods of
+ handling the non-option ARGV-elements.
+ See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
+
+ Long-named options begin with `--' instead of `-'.
+ Their names may be abbreviated as long as the abbreviation is unique
+ or is an exact match for some defined option. If they have an
+ argument, it follows the option name in the same ARGV-element, separated
+ from the option name by a `=', or else the in next ARGV-element.
+ When `getopt' finds a long-named option, it returns 0 if that option's
+ `flag' field is nonzero, the value of the option's `val' field
+ if the `flag' field is zero.
+
+ The elements of ARGV aren't really const, because we permute them.
+ But we pretend they're const in the prototype to be compatible
+ with other systems.
+
+ LONGOPTS is a vector of `struct option' terminated by an
+ element containing a name which is zero.
+
+ LONGIND returns the index in LONGOPT of the long-named option found.
+ It is only valid when a long-named option has been found by the most
+ recent call.
+
+ If LONG_ONLY is nonzero, '-' as well as '--' can introduce
+ long-named options. */
+
+int
+_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
+ int argc;
+ char *const *argv;
+ const char *optstring;
+ const struct option *longopts;
+ int *longind;
+ int long_only;
+{
+ int print_errors = opterr;
+ if (optstring[0] == ':')
+ print_errors = 0;
+
+ optarg = NULL;
+
+ if (optind == 0 || !__getopt_initialized)
+ {
+ if (optind == 0)
+ optind = 1; /* Don't scan ARGV[0], the program name. */
+ optstring = _getopt_initialize (argc, argv, optstring);
+ __getopt_initialized = 1;
+ }
+
+ /* Test whether ARGV[optind] points to a non-option argument.
+ Either it does not have option syntax, or there is an environment flag
+ from the shell indicating it is not an option. The later information
+ is only used when the used in the GNU libc. */
+#ifdef _LIBC
+# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \
+ || (optind < nonoption_flags_len \
+ && __getopt_nonoption_flags[optind] == '1'))
+#else
+# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
+#endif
+
+ if (nextchar == NULL || *nextchar == '\0')
+ {
+ /* Advance to the next ARGV-element. */
+
+ /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
+ moved back by the user (who may also have changed the arguments). */
+ if (last_nonopt > optind)
+ last_nonopt = optind;
+ if (first_nonopt > optind)
+ first_nonopt = optind;
+
+ if (ordering == PERMUTE)
+ {
+ /* If we have just processed some options following some non-options,
+ exchange them so that the options come first. */
+
+ if (first_nonopt != last_nonopt && last_nonopt != optind)
+ exchange ((char **) argv);
+ else if (last_nonopt != optind)
+ first_nonopt = optind;
+
+ /* Skip any additional non-options
+ and extend the range of non-options previously skipped. */
+
+ while (optind < argc && NONOPTION_P)
+ optind++;
+ last_nonopt = optind;
+ }
+
+ /* The special ARGV-element `--' means premature end of options.
+ Skip it like a null option,
+ then exchange with previous non-options as if it were an option,
+ then skip everything else like a non-option. */
+
+ if (optind != argc && !strcmp (argv[optind], "--"))
+ {
+ optind++;
+
+ if (first_nonopt != last_nonopt && last_nonopt != optind)
+ exchange ((char **) argv);
+ else if (first_nonopt == last_nonopt)
+ first_nonopt = optind;
+ last_nonopt = argc;
+
+ optind = argc;
+ }
+
+ /* If we have done all the ARGV-elements, stop the scan
+ and back over any non-options that we skipped and permuted. */
+
+ if (optind == argc)
+ {
+ /* Set the next-arg-index to point at the non-options
+ that we previously skipped, so the caller will digest them. */
+ if (first_nonopt != last_nonopt)
+ optind = first_nonopt;
+ return -1;
+ }
+
+ /* If we have come to a non-option and did not permute it,
+ either stop the scan or describe it to the caller and pass it by. */
+
+ if (NONOPTION_P)
+ {
+ if (ordering == REQUIRE_ORDER)
+ return -1;
+ optarg = argv[optind++];
+ return 1;
+ }
+
+ /* We have found another option-ARGV-element.
+ Skip the initial punctuation. */
+
+ nextchar = (argv[optind] + 1
+ + (longopts != NULL && argv[optind][1] == '-'));
+ }
+
+ /* Decode the current option-ARGV-element. */
+
+ /* Check whether the ARGV-element is a long option.
+
+ If long_only and the ARGV-element has the form "-f", where f is
+ a valid short option, don't consider it an abbreviated form of
+ a long option that starts with f. Otherwise there would be no
+ way to give the -f short option.
+
+ On the other hand, if there's a long option "fubar" and
+ the ARGV-element is "-fu", do consider that an abbreviation of
+ the long option, just like "--fu", and not "-f" with arg "u".
+
+ This distinction seems to be the most useful approach. */
+
+ if (longopts != NULL
+ && (argv[optind][1] == '-'
+ || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
+ {
+ char *nameend;
+ const struct option *p;
+ const struct option *pfound = NULL;
+ int exact = 0;
+ int ambig = 0;
+ int indfound = -1;
+ int option_index;
+
+ for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
+ /* Do nothing. */ ;
+
+ /* Test all long options for either exact match
+ or abbreviated matches. */
+ for (p = longopts, option_index = 0; p->name; p++, option_index++)
+ if (!strncmp (p->name, nextchar, nameend - nextchar))
+ {
+ if ((unsigned int) (nameend - nextchar)
+ == (unsigned int) strlen (p->name))
+ {
+ /* Exact match found. */
+ pfound = p;
+ indfound = option_index;
+ exact = 1;
+ break;
+ }
+ else if (pfound == NULL)
+ {
+ /* First nonexact match found. */
+ pfound = p;
+ indfound = option_index;
+ }
+ else
+ /* Second or later nonexact match found. */
+ ambig = 1;
+ }
+
+ if (ambig && !exact)
+ {
+ if (print_errors)
+ fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
+ argv[0], argv[optind]);
+ nextchar += strlen (nextchar);
+ optind++;
+ optopt = 0;
+ return '?';
+ }
+
+ if (pfound != NULL)
+ {
+ option_index = indfound;
+ optind++;
+ if (*nameend)
+ {
+ /* Don't test has_arg with >, because some C compilers don't
+ allow it to be used on enums. */
+ if (pfound->has_arg)
+ optarg = nameend + 1;
+ else
+ {
+ if (print_errors)
+ {
+ if (argv[optind - 1][1] == '-')
+ /* --option */
+ fprintf (stderr,
+ _("%s: option `--%s' doesn't allow an argument\n"),
+ argv[0], pfound->name);
+ else
+ /* +option or -option */
+ fprintf (stderr,
+ _("%s: option `%c%s' doesn't allow an argument\n"),
+ argv[0], argv[optind - 1][0], pfound->name);
+ }
+
+ nextchar += strlen (nextchar);
+
+ optopt = pfound->val;
+ return '?';
+ }
+ }
+ else if (pfound->has_arg == 1)
+ {
+ if (optind < argc)
+ optarg = argv[optind++];
+ else
+ {
+ if (print_errors)
+ fprintf (stderr,
+ _("%s: option `%s' requires an argument\n"),
+ argv[0], argv[optind - 1]);
+ nextchar += strlen (nextchar);
+ optopt = pfound->val;
+ return optstring[0] == ':' ? ':' : '?';
+ }
+ }
+ nextchar += strlen (nextchar);
+ if (longind != NULL)
+ *longind = option_index;
+ if (pfound->flag)
+ {
+ *(pfound->flag) = pfound->val;
+ return 0;
+ }
+ return pfound->val;
+ }
+
+ /* Can't find it as a long option. If this is not getopt_long_only,
+ or the option starts with '--' or is not a valid short
+ option, then it's an error.
+ Otherwise interpret it as a short option. */
+ if (!long_only || argv[optind][1] == '-'
+ || my_index (optstring, *nextchar) == NULL)
+ {
+ if (print_errors)
+ {
+ if (argv[optind][1] == '-')
+ /* --option */
+ fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
+ argv[0], nextchar);
+ else
+ /* +option or -option */
+ fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
+ argv[0], argv[optind][0], nextchar);
+ }
+ nextchar = (char *) "";
+ optind++;
+ optopt = 0;
+ return '?';
+ }
+ }
+
+ /* Look at and handle the next short option-character. */
+
+ {
+ char c = *nextchar++;
+ char *temp = my_index (optstring, c);
+
+ /* Increment `optind' when we start to process its last character. */
+ if (*nextchar == '\0')
+ ++optind;
+
+ if (temp == NULL || c == ':')
+ {
+ if (print_errors)
+ {
+ if (posixly_correct)
+ /* 1003.2 specifies the format of this message. */
+ fprintf (stderr, _("%s: illegal option -- %c\n"),
+ argv[0], c);
+ else
+ fprintf (stderr, _("%s: invalid option -- %c\n"),
+ argv[0], c);
+ }
+ optopt = c;
+ return '?';
+ }
+ /* Convenience. Treat POSIX -W foo same as long option --foo */
+ if (temp[0] == 'W' && temp[1] == ';')
+ {
+ char *nameend;
+ const struct option *p;
+ const struct option *pfound = NULL;
+ int exact = 0;
+ int ambig = 0;
+ int indfound = 0;
+ int option_index;
+
+ /* This is an option that requires an argument. */
+ if (*nextchar != '\0')
+ {
+ optarg = nextchar;
+ /* If we end this ARGV-element by taking the rest as an arg,
+ we must advance to the next element now. */
+ optind++;
+ }
+ else if (optind == argc)
+ {
+ if (print_errors)
+ {
+ /* 1003.2 specifies the format of this message. */
+ fprintf (stderr, _("%s: option requires an argument -- %c\n"),
+ argv[0], c);
+ }
+ optopt = c;
+ if (optstring[0] == ':')
+ c = ':';
+ else
+ c = '?';
+ return c;
+ }
+ else
+ /* We already incremented `optind' once;
+ increment it again when taking next ARGV-elt as argument. */
+ optarg = argv[optind++];
+
+ /* optarg is now the argument, see if it's in the
+ table of longopts. */
+
+ for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
+ /* Do nothing. */ ;
+
+ /* Test all long options for either exact match
+ or abbreviated matches. */
+ for (p = longopts, option_index = 0; p->name; p++, option_index++)
+ if (!strncmp (p->name, nextchar, nameend - nextchar))
+ {
+ if ((unsigned int) (nameend - nextchar) == strlen (p->name))
+ {
+ /* Exact match found. */
+ pfound = p;
+ indfound = option_index;
+ exact = 1;
+ break;
+ }
+ else if (pfound == NULL)
+ {
+ /* First nonexact match found. */
+ pfound = p;
+ indfound = option_index;
+ }
+ else
+ /* Second or later nonexact match found. */
+ ambig = 1;
+ }
+ if (ambig && !exact)
+ {
+ if (print_errors)
+ fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
+ argv[0], argv[optind]);
+ nextchar += strlen (nextchar);
+ optind++;
+ return '?';
+ }
+ if (pfound != NULL)
+ {
+ option_index = indfound;
+ if (*nameend)
+ {
+ /* Don't test has_arg with >, because some C compilers don't
+ allow it to be used on enums. */
+ if (pfound->has_arg)
+ optarg = nameend + 1;
+ else
+ {
+ if (print_errors)
+ fprintf (stderr, _("\
+%s: option `-W %s' doesn't allow an argument\n"),
+ argv[0], pfound->name);
+
+ nextchar += strlen (nextchar);
+ return '?';
+ }
+ }
+ else if (pfound->has_arg == 1)
+ {
+ if (optind < argc)
+ optarg = argv[optind++];
+ else
+ {
+ if (print_errors)
+ fprintf (stderr,
+ _("%s: option `%s' requires an argument\n"),
+ argv[0], argv[optind - 1]);
+ nextchar += strlen (nextchar);
+ return optstring[0] == ':' ? ':' : '?';
+ }
+ }
+ nextchar += strlen (nextchar);
+ if (longind != NULL)
+ *longind = option_index;
+ if (pfound->flag)
+ {
+ *(pfound->flag) = pfound->val;
+ return 0;
+ }
+ return pfound->val;
+ }
+ nextchar = NULL;
+ return 'W'; /* Let the application handle it. */
+ }
+ if (temp[1] == ':')
+ {
+ if (temp[2] == ':')
+ {
+ /* This is an option that accepts an argument optionally. */
+ if (*nextchar != '\0')
+ {
+ optarg = nextchar;
+ optind++;
+ }
+ else
+ optarg = NULL;
+ nextchar = NULL;
+ }
+ else
+ {
+ /* This is an option that requires an argument. */
+ if (*nextchar != '\0')
+ {
+ optarg = nextchar;
+ /* If we end this ARGV-element by taking the rest as an arg,
+ we must advance to the next element now. */
+ optind++;
+ }
+ else if (optind == argc)
+ {
+ if (print_errors)
+ {
+ /* 1003.2 specifies the format of this message. */
+ fprintf (stderr,
+ _("%s: option requires an argument -- %c\n"),
+ argv[0], c);
+ }
+ optopt = c;
+ if (optstring[0] == ':')
+ c = ':';
+ else
+ c = '?';
+ }
+ else
+ /* We already incremented `optind' once;
+ increment it again when taking next ARGV-elt as argument. */
+ optarg = argv[optind++];
+ nextchar = NULL;
+ }
+ }
+ return c;
+ }
+}
+
+int
+getopt (argc, argv, optstring)
+ int argc;
+ char *const *argv;
+ const char *optstring;
+{
+ return _getopt_internal (argc, argv, optstring,
+ (const struct option *) 0,
+ (int *) 0,
+ 0);
+}
+
+#endif /* Not ELIDE_CODE. */
+\f
+#ifdef TEST
+
+/* Compile with -DTEST to make an executable for use in testing
+ the above definition of `getopt'. */
+
+int
+main (argc, argv)
+ int argc;
+ char **argv;
+{
+ int c;
+ int digit_optind = 0;
+
+ while (1)
+ {
+ int this_option_optind = optind ? optind : 1;
+
+ c = getopt (argc, argv, "abc:d:0123456789");
+ if (c == -1)
+ break;
+
+ switch (c)
+ {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ if (digit_optind != 0 && digit_optind != this_option_optind)
+ printf ("digits occur in two different argv-elements.\n");
+ digit_optind = this_option_optind;
+ printf ("option %c\n", c);
+ break;
+
+ case 'a':
+ printf ("option a\n");
+ break;
+
+ case 'b':
+ printf ("option b\n");
+ break;
+
+ case 'c':
+ printf ("option c with value `%s'\n", optarg);
+ break;
+
+ case '?':
+ break;
+
+ default:
+ printf ("?? getopt returned character code 0%o ??\n", c);
+ }
+ }
+
+ if (optind < argc)
+ {
+ printf ("non-option ARGV-elements: ");
+ while (optind < argc)
+ printf ("%s ", argv[optind++]);
+ printf ("\n");
+ }
+
+ exit (0);
+}
+
+#endif /* TEST */
--- /dev/null
+/* Declarations for getopt.
+ Copyright (C) 1989,90,91,92,93,94,96,97,98 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#ifndef _GETOPT_H
+
+#ifndef __need_getopt
+# define _GETOPT_H 1
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* For communication from `getopt' to the caller.
+ When `getopt' finds an option that takes an argument,
+ the argument value is returned here.
+ Also, when `ordering' is RETURN_IN_ORDER,
+ each non-option ARGV-element is returned here. */
+
+extern char *optarg;
+
+/* Index in ARGV of the next element to be scanned.
+ This is used for communication to and from the caller
+ and for communication between successive calls to `getopt'.
+
+ On entry to `getopt', zero means this is the first call; initialize.
+
+ When `getopt' returns -1, this is the index of the first of the
+ non-option elements that the caller should itself scan.
+
+ Otherwise, `optind' communicates from one call to the next
+ how much of ARGV has been scanned so far. */
+
+extern int optind;
+
+/* Callers store zero here to inhibit the error message `getopt' prints
+ for unrecognized options. */
+
+extern int opterr;
+
+/* Set to an option character which was unrecognized. */
+
+extern int optopt;
+
+#ifndef __need_getopt
+/* Describe the long-named options requested by the application.
+ The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
+ of `struct option' terminated by an element containing a name which is
+ zero.
+
+ The field `has_arg' is:
+ no_argument (or 0) if the option does not take an argument,
+ required_argument (or 1) if the option requires an argument,
+ optional_argument (or 2) if the option takes an optional argument.
+
+ If the field `flag' is not NULL, it points to a variable that is set
+ to the value given in the field `val' when the option is found, but
+ left unchanged if the option is not found.
+
+ To have a long-named option do something other than set an `int' to
+ a compiled-in constant, such as set a value from `optarg', set the
+ option's `flag' field to zero and its `val' field to a nonzero
+ value (the equivalent single-letter option character, if there is
+ one). For long options that have a zero `flag' field, `getopt'
+ returns the contents of the `val' field. */
+
+struct option
+{
+# if defined __STDC__ && __STDC__
+ const char *name;
+# else
+ char *name;
+# endif
+ /* has_arg can't be an enum because some compilers complain about
+ type mismatches in all the code that assumes it is an int. */
+ int has_arg;
+ int *flag;
+ int val;
+};
+
+/* Names for the values of the `has_arg' field of `struct option'. */
+
+# define no_argument 0
+# define required_argument 1
+# define optional_argument 2
+#endif /* need getopt */
+
+
+/* Get definitions and prototypes for functions to process the
+ arguments in ARGV (ARGC of them, minus the program name) for
+ options given in OPTS.
+
+ Return the option character from OPTS just read. Return -1 when
+ there are no more options. For unrecognized options, or options
+ missing arguments, `optopt' is set to the option letter, and '?' is
+ returned.
+
+ The OPTS string is a list of characters which are recognized option
+ letters, optionally followed by colons, specifying that that letter
+ takes an argument, to be placed in `optarg'.
+
+ If a letter in OPTS is followed by two colons, its argument is
+ optional. This behavior is specific to the GNU `getopt'.
+
+ The argument `--' causes premature termination of argument
+ scanning, explicitly telling `getopt' that there are no more
+ options.
+
+ If OPTS begins with `--', then non-option arguments are treated as
+ arguments to the option '\0'. This behavior is specific to the GNU
+ `getopt'. */
+
+#if (defined __STDC__ && __STDC__) || _WIN32
+# ifdef __GNU_LIBRARY__
+/* Many other libraries have conflicting prototypes for getopt, with
+ differences in the consts, in stdlib.h. To avoid compilation
+ errors, only prototype getopt for the GNU C library. */
+extern int getopt (int __argc, char *const *__argv, const char *__shortopts);
+# else /* not __GNU_LIBRARY__ */
+extern int getopt ();
+# endif /* __GNU_LIBRARY__ */
+
+# ifndef __need_getopt
+extern int getopt_long (int __argc, char *const *__argv, const char *__shortopts,
+ const struct option *__longopts, int *__longind);
+extern int getopt_long_only (int __argc, char *const *__argv,
+ const char *__shortopts,
+ const struct option *__longopts, int *__longind);
+
+/* Internal only. Users should not call this directly. */
+extern int _getopt_internal (int __argc, char *const *__argv,
+ const char *__shortopts,
+ const struct option *__longopts, int *__longind,
+ int __long_only);
+# endif
+#else /* not __STDC__ */
+extern int getopt ();
+# ifndef __need_getopt
+extern int getopt_long ();
+extern int getopt_long_only ();
+
+extern int _getopt_internal ();
+# endif
+#endif /* __STDC__ */
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Make sure we later can get all the definitions and declarations. */
+#undef __need_getopt
+
+#endif /* getopt.h */
--- /dev/null
+/* getopt_long and getopt_long_only entry points for GNU getopt.
+ Copyright (C) 1987,88,89,90,91,92,93,94,96,97,98
+ Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+\f
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "getopt.h"
+
+#if !defined __STDC__ || !__STDC__
+/* This is a separate conditional since some stdc systems
+ reject `defined (const)'. */
+#ifndef const
+#define const
+#endif
+#endif
+
+#include <stdio.h>
+
+/* Comment out all this code if we are using the GNU C Library, and are not
+ actually compiling the library itself. This code is part of the GNU C
+ Library, but also included in many other GNU distributions. Compiling
+ and linking in this code is a waste when using the GNU C library
+ (especially if it is a shared library). Rather than having every GNU
+ program understand `configure --with-gnu-libc' and omit the object files,
+ it is simpler to just do this in the source for each such file. */
+
+#define GETOPT_INTERFACE_VERSION 2
+#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
+#include <gnu-versions.h>
+#if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
+#define ELIDE_CODE
+#endif
+#endif
+
+#ifndef ELIDE_CODE
+
+
+/* This needs to come after some library #include
+ to get __GNU_LIBRARY__ defined. */
+#ifdef __GNU_LIBRARY__
+#include <stdlib.h>
+#endif
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+int
+getopt_long (argc, argv, options, long_options, opt_index)
+ int argc;
+ char *const *argv;
+ const char *options;
+ const struct option *long_options;
+ int *opt_index;
+{
+ return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
+}
+
+/* Like getopt_long, but '-' as well as '--' can indicate a long option.
+ If an option that starts with '-' (not '--') doesn't match a long option,
+ but does match a short option, it is parsed as a short option
+ instead. */
+
+int
+getopt_long_only (argc, argv, options, long_options, opt_index)
+ int argc;
+ char *const *argv;
+ const char *options;
+ const struct option *long_options;
+ int *opt_index;
+{
+ return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
+}
+
+
+#endif /* Not ELIDE_CODE. */
+\f
+#ifdef TEST
+
+#include <stdio.h>
+
+int
+main (argc, argv)
+ int argc;
+ char **argv;
+{
+ int c;
+ int digit_optind = 0;
+
+ while (1)
+ {
+ int this_option_optind = optind ? optind : 1;
+ int option_index = 0;
+ static struct option long_options[] =
+ {
+ {"add", 1, 0, 0},
+ {"append", 0, 0, 0},
+ {"delete", 1, 0, 0},
+ {"verbose", 0, 0, 0},
+ {"create", 0, 0, 0},
+ {"file", 1, 0, 0},
+ {0, 0, 0, 0}
+ };
+
+ c = getopt_long (argc, argv, "abc:d:0123456789",
+ long_options, &option_index);
+ if (c == -1)
+ break;
+
+ switch (c)
+ {
+ case 0:
+ printf ("option %s", long_options[option_index].name);
+ if (optarg)
+ printf (" with arg %s", optarg);
+ printf ("\n");
+ break;
+
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ if (digit_optind != 0 && digit_optind != this_option_optind)
+ printf ("digits occur in two different argv-elements.\n");
+ digit_optind = this_option_optind;
+ printf ("option %c\n", c);
+ break;
+
+ case 'a':
+ printf ("option a\n");
+ break;
+
+ case 'b':
+ printf ("option b\n");
+ break;
+
+ case 'c':
+ printf ("option c with value `%s'\n", optarg);
+ break;
+
+ case 'd':
+ printf ("option d with value `%s'\n", optarg);
+ break;
+
+ case '?':
+ break;
+
+ default:
+ printf ("?? getopt returned character code 0%o ??\n", c);
+ }
+ }
+
+ if (optind < argc)
+ {
+ printf ("non-option ARGV-elements: ");
+ while (optind < argc)
+ printf ("%s ", argv[optind++]);
+ printf ("\n");
+ }
+
+ exit (0);
+}
+
+#endif /* TEST */
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup Label="ProjectConfigurations">
+ <ProjectConfiguration Include="Debug|Win32">
+ <Configuration>Debug</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|Win32">
+ <Configuration>Release</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ </ItemGroup>
+ <PropertyGroup Label="Globals">
+ <ProjectGuid>{46E26F86-F1D2-40D1-B9DC-AF844622D65D}</ProjectGuid>
+ <Keyword>Win32Proj</Keyword>
+ <RootNamespace>lib</RootNamespace>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <UseDebugLibraries>true</UseDebugLibraries>
+ <PlatformToolset>v110</PlatformToolset>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <UseDebugLibraries>false</UseDebugLibraries>
+ <PlatformToolset>v110</PlatformToolset>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+ <ImportGroup Label="ExtensionSettings">
+ </ImportGroup>
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <PropertyGroup Label="UserMacros" />
+ <PropertyGroup />
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <ClCompile>
+ <PrecompiledHeader>
+ </PrecompiledHeader>
+ <WarningLevel>Level3</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ </ClCompile>
+ <Link>
+ <SubSystem>Windows</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ </Link>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <PrecompiledHeader>
+ </PrecompiledHeader>
+ <Optimization>MaxSpeed</Optimization>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ </ClCompile>
+ <Link>
+ <SubSystem>Windows</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <OptimizeReferences>true</OptimizeReferences>
+ </Link>
+ </ItemDefinitionGroup>
+ <ItemGroup>
+ <ClCompile Include="addr.c" />
+ <ClCompile Include="arcfour.c" />
+ <ClCompile Include="asprintf.c" />
+ <ClCompile Include="authhash.c" />
+ <ClCompile Include="base64.c" />
+ <ClCompile Include="basen.c" />
+ <ClCompile Include="bits.c" />
+ <ClCompile Include="cache.c" />
+ <ClCompile Include="charset.c" />
+ <ClCompile Include="charsetf.c" />
+ <ClCompile Include="client-common.c" />
+ <ClCompile Include="client-stubs.c">
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+ </ClCompile>
+ <ClCompile Include="client.c" />
+ <ClCompile Include="configuration.c" />
+ <ClCompile Include="dateparse.c" />
+ <ClCompile Include="disorder-win32.c" />
+ <ClCompile Include="eventdist.c" />
+ <ClCompile Include="eventlog.c" />
+ <ClCompile Include="fprintf.c" />
+ <ClCompile Include="getopt.c" />
+ <ClCompile Include="getopt1.c" />
+ <ClCompile Include="hash.c" />
+ <ClCompile Include="hex.c" />
+ <ClCompile Include="inputline.c" />
+ <ClCompile Include="kvp.c" />
+ <ClCompile Include="log.c" />
+ <ClCompile Include="mem.c" />
+ <ClCompile Include="mime.c" />
+ <ClCompile Include="printf.c" />
+ <ClCompile Include="queue-rights.c" />
+ <ClCompile Include="queue.c" />
+ <ClCompile Include="rights.c" />
+ <ClCompile Include="selection.c" />
+ <ClCompile Include="signame.c" />
+ <ClCompile Include="sink.c" />
+ <ClCompile Include="snprintf.c" />
+ <ClCompile Include="socketio.c" />
+ <ClCompile Include="split.c" />
+ <ClCompile Include="strptime.c" />
+ <ClCompile Include="syscalls.c" />
+ <ClCompile Include="table.c" />
+ <ClCompile Include="unicode.c" />
+ <ClCompile Include="unidata.c" />
+ <ClCompile Include="url.c" />
+ <ClCompile Include="validity.c" />
+ <ClCompile Include="vector.c" />
+ <ClCompile Include="version.c" />
+ <ClCompile Include="versionstring.c" />
+ <ClCompile Include="xgetdate.c" />
+ </ItemGroup>
+ <ItemGroup>
+ <ClInclude Include="addr.h" />
+ <ClInclude Include="arcfour.h" />
+ <ClInclude Include="authhash.h" />
+ <ClInclude Include="base64.h" />
+ <ClInclude Include="basen.h" />
+ <ClInclude Include="bits.h" />
+ <ClInclude Include="byte-order.h" />
+ <ClInclude Include="cache.h" />
+ <ClInclude Include="charset.h" />
+ <ClInclude Include="client-common.h" />
+ <ClInclude Include="client-stubs.h" />
+ <ClInclude Include="client.h" />
+ <ClInclude Include="common.h" />
+ <ClInclude Include="configuration.h" />
+ <ClInclude Include="dateparse.h" />
+ <ClInclude Include="defs.h" />
+ <ClInclude Include="disorder-win32.h" />
+ <ClInclude Include="disorder.h" />
+ <ClInclude Include="eventdist.h" />
+ <ClInclude Include="eventlog.h" />
+ <ClInclude Include="getopt.h" />
+ <ClInclude Include="hash.h" />
+ <ClInclude Include="heap.h" />
+ <ClInclude Include="hex.h" />
+ <ClInclude Include="inputline.h" />
+ <ClInclude Include="kvp.h" />
+ <ClInclude Include="log.h" />
+ <ClInclude Include="mem.h" />
+ <ClInclude Include="mime.h" />
+ <ClInclude Include="printf.h" />
+ <ClInclude Include="queue.h" />
+ <ClInclude Include="rights.h" />
+ <ClInclude Include="selection.h" />
+ <ClInclude Include="signame.h" />
+ <ClInclude Include="sink.h" />
+ <ClInclude Include="socketio.h" />
+ <ClInclude Include="speaker-protocol.h" />
+ <ClInclude Include="split.h" />
+ <ClInclude Include="strptime.h" />
+ <ClInclude Include="syscalls.h" />
+ <ClInclude Include="table.h" />
+ <ClInclude Include="timeval.h" />
+ <ClInclude Include="unicode.h" />
+ <ClInclude Include="unidata.h" />
+ <ClInclude Include="url.h" />
+ <ClInclude Include="vacopy.h" />
+ <ClInclude Include="validity.h" />
+ <ClInclude Include="vector.h" />
+ <ClInclude Include="version.h" />
+ </ItemGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+ <ImportGroup Label="ExtensionTargets">
+ </ImportGroup>
+</Project>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup>
+ <Filter Include="Source Files">
+ <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+ <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+ </Filter>
+ <Filter Include="Header Files">
+ <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+ <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+ </Filter>
+ <Filter Include="Resource Files">
+ <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+ <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+ </Filter>
+ </ItemGroup>
+ <ItemGroup>
+ <ClCompile Include="mem.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="printf.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="log.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="sink.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="vector.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="disorder-win32.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="addr.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="syscalls.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="rights.c">
+ <Filter>Header Files</Filter>
+ </ClCompile>
+ <ClCompile Include="configuration.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="table.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="arcfour.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="asprintf.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="authhash.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="base64.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="basen.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="cache.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="hash.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="hex.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="inputline.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="kvp.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="mime.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="signame.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="snprintf.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="split.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="validity.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="unicode.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="unidata.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="socketio.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="client.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="client-common.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="client-stubs.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="bits.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="eventdist.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="eventlog.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="queue.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="queue-rights.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="selection.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="url.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="getopt.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="getopt1.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="fprintf.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="charset.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="charsetf.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="dateparse.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="xgetdate.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="version.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="strptime.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="versionstring.c">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ </ItemGroup>
+ <ItemGroup>
+ <ClInclude Include="common.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="log.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="printf.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="disorder.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="vacopy.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="sink.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="disorder-win32.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="mem.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="vector.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="addr.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="syscalls.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="configuration.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="rights.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="speaker-protocol.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="byte-order.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="table.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="arcfour.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="authhash.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="base64.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="basen.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="cache.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="dateparse.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="hash.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="heap.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="hex.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="inputline.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="kvp.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="mime.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="signame.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="split.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="validity.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="unicode.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="unidata.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="socketio.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="client.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="client-common.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="client-stubs.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="bits.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="eventdist.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="eventlog.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="queue.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="selection.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="timeval.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="url.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="getopt.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="charset.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="version.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="strptime.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="defs.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ </ItemGroup>
+</Project>
\ No newline at end of file
if(logdate) {
char timebuf[64];
struct tm *tm;
+ time_t t;
gettimeofday(&tv, 0);
- tm = localtime(&tv.tv_sec);
+ t = tv.tv_sec;
+ tm = localtime(&t);
strftime(timebuf, sizeof timebuf, "%Y-%m-%d %H:%M:%S %Z", tm);
fprintf(fp, "%s: ", timebuf);
}
}
fputs(msg, fp);
fputc('\n', fp);
+ fflush(fp);
}
#if HAVE_SYSLOG_H
*
* The return value may or may not be @p buffer.
*/
+#if !_WIN32
#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
const char *format_error(enum error_class ec, int err, char buffer[], size_t bufsize) {
+#if _WIN32
+ size_t n;
+ switch(ec) {
+ default:
+ if(!FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
+ NULL,
+ err,
+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+ buffer,
+ bufsize,
+ NULL))
+ disorder_fatal(0, "FormatMessage failed");
+ n = strlen(buffer);
+ while(n > 0 && isspace((unsigned char)buffer[n-1]))
+ --n;
+ buffer[n] = 0;
+ return buffer;
+ case ec_errno:
+ strerror_s(buffer, bufsize, err);
+ return buffer;
+ case ec_none:
+ return "(none)";
+ }
+#else
switch(ec) {
default:
return strerror(err);
case ec_none:
return "(none)";
}
+#endif
}
/*
/** @brief @c errno number space */
ec_errno,
+ /** @brief Windows GetLastError/WSAGetLastError return value */
+ ec_windows,
+
/** @brief getaddrinfo() return value */
ec_getaddrinfo,
};
+#if _WIN32
+# define ec_native ec_windows
+# define ec_socket ec_windows
+#else
# define ec_native ec_errno
# define ec_socket ec_errno
+#endif
void elog(int pri, enum error_class, int errno_value, const char *fmt, va_list ap);
+declspec(noreturn)
void disorder_fatal(int errno_value, const char *msg, ...) attribute((noreturn))
attribute((format (printf, 2, 3)));
+declspec(noreturn)
void disorder_fatal_ec(enum error_class ec, int errno_value, const char *msg, ...) attribute((noreturn))
attribute((format (printf, 3, 4)));
void disorder_error(int errno_value, const char *msg, ...)
return ret;
}
+#if !_WIN32
pid_t xfork(void) {
pid_t pid;
mustnotbeminus1("fcntl F_GETFD",
fcntl(fd, F_GETFD)) | FD_CLOEXEC));
}
+#endif
-void xlisten(int fd, int q) {
+void xlisten(SOCKET fd, int q) {
mustnotbeminus1("listen", listen(fd, q));
}
-void xshutdown(int fd, int how) {
+void xshutdown(SOCKET fd, int how) {
mustnotbeminus1("shutdown", shutdown(fd, how));
}
-void xsetsockopt(int fd, int l, int o, const void *v, socklen_t vl) {
+void xsetsockopt(SOCKET fd, int l, int o, const void *v, socklen_t vl) {
mustnotbeminus1("setsockopt", setsockopt(fd, l, o, v, vl));
}
-int xsocket(int d, int t, int p) {
- return mustnotbeminus1("socket", socket(d, t, p));
+SOCKET xsocket(int d, int t, int p) {
+ SOCKET s = socket(d, t, p);
+ if(s == INVALID_SOCKET)
+ disorder_fatal(errno, "error calling socket");
+ return s;
}
-void xconnect(int fd, const struct sockaddr *sa, socklen_t sl) {
+void xconnect(SOCKET fd, const struct sockaddr *sa, socklen_t sl) {
mustnotbeminus1("connect", connect(fd, sa, sl));
}
+#if !_WIN32
void xsigprocmask(int how, const sigset_t *set, sigset_t *oldset) {
mustnotbeminus1("sigprocmask", sigprocmask(how, set, oldset));
}
void xsigaction(int sig, const struct sigaction *sa, struct sigaction *oldsa) {
mustnotbeminus1("sigaction", sigaction(sig, sa, oldsa));
}
+#endif
int xprintf(const char *fmt, ...) {
va_list ap;
return errno;
}
+#if !_WIN32
int xnice(int inc) {
int ret;
disorder_fatal(errno, "error calling nice");
return ret;
}
+#endif
void xgettimeofday(struct timeval *tv, struct timezone *tz) {
mustnotbeminus1("gettimeofday", gettimeofday(tv, tz));
return tv.tv_sec;
}
+#if !_WIN32
void xnanosleep(const struct timespec *req, struct timespec *rem) {
mustnotbeminus1("nanosleep", nanosleep(req, rem));
}
+#endif
/*
Local Variables:
#endif
#include <signal.h>
+#if !_WIN32
pid_t xfork(void);
void xclose_guts(const char *, int, int);
#define xclose(fd) xclose_guts(__FILE__, __LINE__, fd)
void xdup2(int, int);
void xpipe(int *);
int xfcntl(int, int, long);
-void xlisten(int, int);
-void xshutdown(int, int);
-void xsetsockopt(int, int, int, const void *, socklen_t);
-int xsocket(int, int, int);
-void xconnect(int, const struct sockaddr *, socklen_t);
void xsigprocmask(int how, const sigset_t *set, sigset_t *oldset);
void xsigaction(int sig, const struct sigaction *sa, struct sigaction *oldsa);
+int xnice(int);
+void xgettime(clockid_t clk_id, struct timespec *tp);
+void xnanosleep(const struct timespec *req, struct timespec *rem);
+#endif
+void xlisten(SOCKET, int);
+void xshutdown(SOCKET, int);
+void xsetsockopt(SOCKET, int, int, const void *, socklen_t);
+SOCKET xsocket(int, int, int);
+void xconnect(SOCKET, const struct sockaddr *, socklen_t);
int xprintf(const char *, ...)
attribute((format (printf, 1, 2)));
void xfclose(FILE *);
-int xnice(int);
void xgettimeofday(struct timeval *, struct timezone *);
time_t xtime(time_t *when);
-void xgettime(clockid_t clk_id, struct timespec *tp);
-void xnanosleep(const struct timespec *req, struct timespec *rem);
/* the above all call @fatal@ if the system call fails */
void nonblock(int fd);
return utf8_to_utf16(s, strlen(s), 0);
}
+#if _WIN32
+static inline wchar_t *utf8nt_to_wchar(const char *s) {
+ return (wchar_t *)utf8nt_to_utf16(s);
+}
+
+static inline char *wcharnt_to_utf8(const wchar_t *s) {
+ return utf16nt_to_utf8((const uint16_t *)s);
+}
+#else
static inline wchar_t *utf8nt_to_wchar(const char *s) {
return (wchar_t *)utf8nt_to_utf32(s);
}
static inline char *wcharnt_to_utf8(const wchar_t *s) {
return utf32nt_to_utf8((const uint32_t *)s);
}
+#endif
#endif /* UNICODE_H */
tp->tm_year = tp->tm_mon = tp->tm_mday = tp->tm_wday = INT_MIN;
tp->tm_hour = tp->tm_sec = tp->tm_min = INT_MIN;
tp->tm_isdst = -1;
+#if !_WIN32
tp->tm_gmtoff = 0;
tp->tm_zone = NULL;
+#endif
result = my_strptime (string, line, tp);
if (result && *result == '\0')
break;
/* Get current time. */
time (&timer);
- localtime_r (&timer, &tm);
+#if _WIN32
+ localtime_s(&tm, &timer);
+#else
+ localtime_r(&timer, &tm);
+#endif
/* If only the weekday is given, today is assumed if the given day
is equal to the current day and next week if it is less. */
~mdw / disorder / commitdiff