/*
* convert address into a reverse lookup address
*/
static void
mkptrname(char *ip, char *rip, int rlen)
{
char buf[128];
char *p, *np;
int len;
if(strstr(ip, "in-addr.arpa") || strstr(ip, "IN-ADDR.ARPA")){
nstrcpy(rip, ip, rlen);
return;
}
nstrcpy(buf, ip, sizeof buf);
for(p = buf; *p; p++)
;
*p = '.';
np = rip;
len = 0;
while(p >= buf){
len++;
p--;
if(*p == '.'){
memmove(np, p+1, len);
np += len;
len = 0;
}
}
memmove(np, p+1, len);
np += len;
strcpy(np, "in-addr.arpa");
}
/*
* Optionally translate an old format uucp name into a new one, e.g.
* "mach1!mach2!user" becomes "*****@*****.**". This optional because
* some information is necessarily lost (e.g. the route it got here
* via) and if we don't have the host in our routing tables, we lose.
* XXX THIS IS NO LONGER VALID WITH THE NEW UUCP PROJECT PLANS TO
* REGISTER UUCP HOSTS IN THE STANDARD INTERNET NAMESPACE, E.G.
* ihnp4 BECOMES "ihnp4.att.com".
*/
char *
unuucp(char *name)
{
register char *np, *hp, *cp;
char result[100];
char tname[300];
if (UnUUCP==0 &&
((cp = value("conv"))==NOSTR || strcmp(cp, "internet")))
return name;
if (debug) fprintf(stderr, "unuucp(%s)\n", name);
nstrcpy(tname, sizeof (tname), name);
np = strrchr(tname, '!');
if (np == NOSTR)
return name;
*np++ = 0;
hp = strrchr(tname, '!');
if (hp == NOSTR)
hp = tname;
else
*hp++ = 0;
cp = strchr(np, '@');
if (cp == NOSTR)
cp = strchr(np, '%');
if (cp)
*cp = 0;
if (debug) fprintf(stderr, "host %s, name %s\n", hp, np);
snprintf(result, sizeof (result), "%s@%s.UUCP", np, hp);
if (debug) fprintf(stderr, "unuucp returns %s\n", result);
return savestr(result);
}
int
yyinit(char str[])
{
static char lexbuf[BUFSIZ];
netbuf[0] = 0;
if (strlen(str) >= sizeof lexbuf - 1)
return(-1);
nexttok = 0;
nstrcpy(lexbuf, sizeof (lexbuf), str);
charp = lexbuf;
return(0);
}
// ////////////////////////////////////////////////////////////////////////////
char *TimeVal::FormatStringInterval(char *buffer, unsigned int max_length) const
{
if (max_length < LengthInterval_TimeVal) {
char tmp_buffer[LengthInterval_TimeVal + 1];
return(nstrcpy(buffer, FormatStringInterval(tmp_buffer), max_length));
}
// This gets dddddd hh:mm:ss
TimeT tmp_time_t(tv_sec);
tmp_time_t.ToStringInterval(buffer);
return(AppendFractionalPortion(LengthInterval_TimeT, buffer));
}
// ////////////////////////////////////////////////////////////////////////////
char *TimeVal::FormatString(const TimeTM &in_tm, char *buffer,
unsigned int max_length) const
{
if (max_length < Length_TimeVal) {
char tmp_buffer[Length_TimeVal + 1];
return(nstrcpy(buffer, FormatString(in_tm, tmp_buffer),
max_length));
}
// This gets YYYY-MM-DD hh:mm:ss
in_tm.ToString(buffer);
return(AppendFractionalPortion(Length_TimeT, buffer));
}
void register_name(struct subnet_record *subrec,
const char *name, int type, uint16 nb_flags,
register_name_success_function success_fn,
register_name_fail_function fail_fn,
struct userdata_struct *userdata)
{
struct nmb_name nmbname;
nstring nname;
if (strlen(name)+1 > sizeof(nstring)) {
memcpy(nname, name,sizeof(nstring)-1);
nname[sizeof(nstring)-1] = '\0';
DEBUG(0,("register_name: NetBIOS name %s is too long. Truncating to %s\n",
name, nname));
} else {
nstrcpy(nname,name);
}
make_nmb_name(&nmbname, nname, type);
/* Always set the NB_ACTIVE flag on the name we are
registering. Doesn't make sense without it.
*/
nb_flags |= NB_ACTIVE;
if (subrec == unicast_subnet) {
/* we now always do multi-homed registration if we are
registering to a WINS server. This copes much
better with complex WINS setups */
multihomed_register_name(&nmbname, nb_flags,
success_fn, fail_fn);
return;
}
if (queue_register_name(subrec,
register_name_response,
register_name_timeout_response,
success_fn,
fail_fn,
userdata,
&nmbname,
nb_flags) == NULL) {
DEBUG(0,("register_name: Failed to send packet trying to register name %s\n",
nmb_namestr(&nmbname)));
}
}
static void
optim1(char netstr[], char name[])
{
char path[STSIZ], rpath[STSIZ];
register char *cp, *cp2;
register int tp, nc;
cp = netstr;
prefer(cp);
*name = '\0';
/*
* If the address ultimately points back to us,
* just return a null network path.
*/
if ((int)strlen(cp) > 1 && cp[strlen(cp) - 2] == LOCAL)
return;
while (*cp != 0) {
*path = '\0';
tp = ntype(cp[1]);
nc = cp[1];
while (*cp && tp == ntype(cp[1])) {
stradd(path, sizeof (path), *cp++);
cp++;
}
switch (netkind(tp)) {
default:
nstrcpy(rpath, sizeof (rpath), path);
break;
case IMPLICIT:
optimimp(path, rpath);
break;
case EXPLICIT:
optimex(path, rpath);
break;
}
for (cp2 = rpath; *cp2 != 0; cp2++) {
stradd(name, BUFSIZ, *cp2);
stradd(name, BUFSIZ, nc);
}
}
optiboth(name);
prefer(name);
}
/*
* Deal with arpa net addresses. The way this is done is strange.
* name contains an "@" or "%". Look up the machine after it in
* the hash table. If it isn't found, return name unmolested.
* If ???, return name unmolested.
* Otherwise, delete the "@" or "%" and the machine after it from
* name, and return the new string.
*/
static char *
arpafix(char name[], char from[])
{
register char *cp;
register int arpamach;
char newname[BUFSIZ];
if (debug) {
fprintf(stderr, "arpafix(%s, %s)\n", name, from);
}
cp = strrchr(name, '@');
if (cp == NOSTR)
cp = strrchr(name, '%');
if (cp == NOSTR) {
fprintf(stderr,
gettext("Something's amiss -- no @ or %% in arpafix\n"));
return(name);
}
cp++;
arpamach = netlook(cp, '@');
if (debug)
fprintf(stderr,
"cp '%s', arpamach %o, nettypes arpamach %o LOCAL %o\n",
cp, arpamach, nettype(arpamach), nettype(LOCAL));
if (arpamach == 0) {
if (debug)
fprintf(stderr, "machine %s unknown, uses: %s\n",
cp, name);
return(name);
}
if (((nettype(arpamach) & nettype(LOCAL)) & ~AN) == 0) {
if (debug)
fprintf(stderr, "machine %s known but remote, uses: %s\n",
cp, name);
return(name);
}
nstrcpy(newname, sizeof (newname), name);
cp = strrchr(newname, '@');
if (cp == NOSTR)
cp = strrchr(newname, '%');
*cp = 0;
if (debug) fprintf(stderr, "local address, return '%s'\n", newname);
return(savestr(newname));
}
int CreateNewWiFiWindow(HWND hWnd, char* selssid)
{
MSG msg;
MAINWINCREATE CreateInfo;
LoadWindowStr();
memset(my_ssid, 0, sizeof(my_ssid));
nstrcpy(my_ssid, selssid, strlen(selssid));
hWnd = GetMainWindowHandle(hWnd);
CreateInfo.dwStyle = WS_VISIBLE|WS_BORDER|WS_CAPTION;
CreateInfo.dwExStyle = WS_EX_NONE;
CreateInfo.spCaption = LoadStrByID(MID_WIFI_SETTING);
CreateInfo.hMenu = 0;
CreateInfo.hIcon = 0;
CreateInfo.MainWindowProc = NewWiFiWinProc;
CreateInfo.lx = 0;
CreateInfo.ty = 0;
CreateInfo.rx = g_rcScr.right;
CreateInfo.by = g_rcScr.bottom;
CreateInfo.iBkColor = 0x00FFA2BE;
CreateInfo.dwAddData = 0;
CreateInfo.hHosting = hWnd;
if (LoadBitmap(HDC_SCREEN,&wifibkg,GetBmpPath("submenubg.jpg"))) {
return 0;
}
WififHwnd = CreateMainWindow(&CreateInfo);
if (WififHwnd == HWND_INVALID) {
return -1;
}
ShowWindow(WififHwnd, SW_SHOWNORMAL);
while (GetMessage(&msg,WififHwnd))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
MainWindowThreadCleanup(WififHwnd);
return 0;
}
//2006.08.03 ssr
//add '0' to pre str
char *Pad0Str(char *buf, int size,char *value)
{
//printf("value: %s\n",value);
int l=0;
l = strlen(value);
if (l == size)
{
nstrcpy(buf,value,size);
return value;
}
if (gOptions.PinPreAdd0)
memset(buf,'0',size);
else
memset(buf,' ',size);
//printf("buf: %s\n",buf);
memcpy(buf+(size-l),value,l);
//printf("buf2: %s\n",buf);
return buf;
}
/*
* Determine the current folder directory name.
*/
int
getfold(char *name)
{
char *folder;
if ((folder = value("folder")) == NOSTR || *folder == '\0')
return (-1);
/*
* If name looks like a folder name, don't try
* to expand it, to prevent infinite recursion.
*/
if (*folder != '+' && (folder = expand(folder)) == NOSTR ||
*folder == '\0')
return (-1);
if (*folder == '/') {
nstrcpy(name, BUFSIZ, folder);
} else
snprintf(name, BUFSIZ, "%s/%s", homedir, folder);
return (0);
}
int
exec(char *path, char *argv[])
{
int i;
char buf[400], *p;
struct msg m;
for (p = buf, i = 0; argv[i]; i++)
p += nstrcpy(p, argv[i]) + 1;
*p = 0;
m.p1 = path;
m.p2 = buf;
m.i1 = p - buf + 1; // copy cnt
m.type = MSG_EXEC;
sys_msg(BOTH, &m, TASK_MM);
return 0;
}
static int
optimex(char net[], char name[])
{
register char *cp, *rp;
register int m;
nstrcpy(name, STSIZ, net);
cp = name;
if (strlen(cp) == 0)
return(-1);
if (cp[strlen(cp)-1] == LOCAL) {
name[0] = 0;
return(0);
}
for (cp = name; *cp; cp++) {
m = *cp;
rp = strrchr(cp+1, m);
if (rp != NOSTR)
strcpy(cp, rp);
}
return(0);
}
// ////////////////////////////////////////////////////////////////////////////
char *TimeTM::ToString(char *buffer, unsigned int max_length) const
{
if (max_length < Length_TimeTM) {
char tmp_buffer[Length_TimeTM + 1];
return(nstrcpy(buffer, ToString(tmp_buffer), max_length));
}
tm tm_data = *this;
tm_data.tm_year = (tm_data.tm_year + 1900) % 10000;
tm_data.tm_mon = (tm_data.tm_mon + 1) % 100;
tm_data.tm_mday %= 100;
tm_data.tm_hour %= 100;
tm_data.tm_min %= 100;
tm_data.tm_sec %= 100;
buffer[0] = ((char) ('0' + (tm_data.tm_year / 1000)));
buffer[1] = ((char) ('0' + ((tm_data.tm_year % 1000) / 100)));
buffer[2] = ((char) ('0' + ((tm_data.tm_year % 100) / 10)));
buffer[3] = ((char) ('0' + (tm_data.tm_year % 10)));
buffer[4] = '-';
buffer[5] = ((char) ('0' + (tm_data.tm_mon / 10)));
buffer[6] = ((char) ('0' + (tm_data.tm_mon % 10)));
buffer[7] = '-';
buffer[8] = ((char) ('0' + (tm_data.tm_mday / 10)));
buffer[9] = ((char) ('0' + (tm_data.tm_mday % 10)));
buffer[10] = ' ';
buffer[11] = ((char) ('0' + (tm_data.tm_hour / 10)));
buffer[12] = ((char) ('0' + (tm_data.tm_hour % 10)));
buffer[13] = ':';
buffer[14] = ((char) ('0' + (tm_data.tm_min / 10)));
buffer[15] = ((char) ('0' + (tm_data.tm_min % 10)));
buffer[16] = ':';
buffer[17] = ((char) ('0' + (tm_data.tm_sec / 10)));
buffer[18] = ((char) ('0' + (tm_data.tm_sec % 10)));
buffer[19] = '\0';
return(buffer);
}
void bar(char *arg)
{
char buf[200];
nstrcpy(buf, sizeof buf, arg);
}
static void
optim(char net[], char name[])
{
char netcomp[BUFSIZ], netstr[STSIZ], xfstr[STSIZ];
register char *cp, *cp2;
register int c;
if (debug) fprintf(stderr, "optim(%s, %s) called\n", net, name);
*netstr = '\0';
cp = net;
for (;;) {
/*
* Rip off next path component into netcomp
*/
cp2 = netcomp;
while (*cp && !any(*cp, metanet))
*cp2++ = *cp++;
*cp2 = 0;
/*
* If we hit null byte, then we just scanned
* the destination user name. Go off and optimize
* if its so.
*/
if (*cp == 0)
break;
if ((c = netlook(netcomp, *cp)) == 0) {
printf(gettext("No host named \"%s\"\n"), netcomp);
err:
nstrcpy(name, BUFSIZ, net);
return;
}
stradd(name, BUFSIZ, c);
stradd(name, BUFSIZ, *cp++);
/*
* If multiple network separators given,
* throw away the extras.
*/
while (any(*cp, metanet))
cp++;
}
if (strlen(netcomp) == 0) {
printf(gettext("net name syntax\n"));
goto err;
}
if (debug) fprintf(stderr, "optim1(%s,%s) called\n", netstr, xfstr);
optim1(netstr, xfstr);
if (debug) fprintf(stderr, "optim1(%s,%s) returns\n", netstr, xfstr);
/*
* Convert back to machine names.
*/
cp = xfstr;
*name = '\0';
while (*cp) {
if ((cp2 = netname(*cp++)) == NOSTR) {
printf(gettext("Made up bad net name\n"));
printf(gettext("Machine code %c (0%o)\n"), cp[-1],
cp[-1]);
printf(gettext("Sorry.\n"));
goto err;
}
nstrcat(name, BUFSIZ, cp2);
stradd(name, BUFSIZ, *cp++);
}
nstrcat(name, BUFSIZ, netcomp);
if (debug) fprintf(stderr, "optim returns %s in name\n", name);
}
/*
* Terminate an editing session by attempting to write out the user's
* file from the temporary. Save any new stuff appended to the file.
*/
int
edstop(
int noremove /* don't allow the file to be removed, trunc instead */
)
{
register int gotcha, c;
register struct message *mp;
FILE *obuf, *ibuf, *tbuf = 0, *readstat;
struct stat statb;
char tempname[STSIZ], *id;
int tmpfd = -1;
if (readonly)
return (0);
holdsigs();
if (Tflag != NOSTR) {
if ((readstat = fopen(Tflag, "w")) == NULL)
Tflag = NOSTR;
}
for (mp = &message[0], gotcha = 0; mp < &message[msgCount]; mp++) {
if (mp->m_flag & MNEW) {
mp->m_flag &= ~MNEW;
mp->m_flag |= MSTATUS;
}
if (mp->m_flag & (MODIFY|MDELETED|MSTATUS))
gotcha++;
if (Tflag != NOSTR && (mp->m_flag & (MREAD|MDELETED)) != 0) {
if ((id = hfield("article-id", mp, addone)) != NOSTR)
fprintf(readstat, "%s\n", id);
}
}
if (Tflag != NOSTR)
fclose(readstat);
if (!gotcha || Tflag != NOSTR)
goto done;
if ((ibuf = fopen(editfile, "r+")) == NULL) {
perror(editfile);
relsesigs();
longjmp(srbuf, 1);
}
lock(ibuf, "r+", 1);
if (fstat(fileno(ibuf), &statb) >= 0 && statb.st_size > mailsize) {
nstrcpy(tempname, STSIZ, "/tmp/mboxXXXXXX");
if ((tmpfd = mkstemp(tempname)) == -1) {
perror(tempname);
fclose(ibuf);
relsesigs();
longjmp(srbuf, 1);
}
if ((obuf = fdopen(tmpfd, "w")) == NULL) {
perror(tempname);
fclose(ibuf);
removefile(tempname);
relsesigs();
(void) close(tmpfd);
longjmp(srbuf, 1);
}
fseek(ibuf, mailsize, 0);
while ((c = getc(ibuf)) != EOF)
putc(c, obuf);
fclose(obuf);
if ((tbuf = fopen(tempname, "r")) == NULL) {
perror(tempname);
fclose(ibuf);
removefile(tempname);
relsesigs();
longjmp(srbuf, 1);
}
removefile(tempname);
}
if ((obuf = fopen(editfile, "r+")) == NULL) {
if ((obuf = fopen(editfile, "w")) == NULL) {
perror(editfile);
fclose(ibuf);
if (tbuf)
fclose(tbuf);
relsesigs();
longjmp(srbuf, 1);
}
}
printf("\"%s\" ", editfile);
flush();
c = 0;
for (mp = &message[0]; mp < &message[msgCount]; mp++) {
if ((mp->m_flag & MDELETED) != 0)
continue;
c++;
if (msend(mp, obuf, 0, fputs) < 0) {
perror(editfile);
fclose(ibuf);
fclose(obuf);
if (tbuf)
fclose(tbuf);
relsesigs();
longjmp(srbuf, 1);
}
}
gotcha = (c == 0 && tbuf == NULL);
if (tbuf != NULL) {
while ((c = getc(tbuf)) != EOF)
putc(c, obuf);
fclose(tbuf);
}
fflush(obuf);
if (fferror(obuf)) {
perror(editfile);
fclose(ibuf);
fclose(obuf);
relsesigs();
longjmp(srbuf, 1);
}
if (gotcha && !noremove && (value("keep") == NOSTR)) {
removefile(editfile);
printf(gettext("removed.\n"));
}
else
printf(gettext("updated.\n"));
fclose(ibuf);
trunc(obuf);
fclose(obuf);
flush();
done:
relsesigs();
return (1);
}
static struct work_record *create_workgroup(const char *name, int ttl)
{
struct work_record *work;
struct subnet_record *subrec;
int t = -1;
if((work = (struct work_record *)malloc(sizeof(*work))) == NULL) {
DEBUG(0,("create_workgroup: malloc fail !\n"));
return NULL;
}
memset((char *)work, '\0', sizeof(*work));
if (strlen(name)+1 > sizeof(nstring)) {
memcpy(work->work_group,name,sizeof(nstring)-1);
work->work_group[sizeof(nstring)-1] = '\0';
DEBUG(0,("create_workgroup: workgroup name %s is too long. Truncating to %s\n",
name, work->work_group ));
} else {
nstrcpy(work->work_group,name);
}
work->serverlist = NULL;
work->RunningElection = False;
work->ElectionCount = 0;
work->announce_interval = 0;
work->needelection = False;
work->needannounce = True;
work->lastannounce_time = time(NULL);
work->mst_state = lp_local_master() ? MST_POTENTIAL : MST_NONE;
work->dom_state = DOMAIN_NONE;
work->log_state = LOGON_NONE;
work->death_time = (ttl != PERMANENT_TTL) ? time(NULL)+(ttl*3) : PERMANENT_TTL;
/* Make sure all token representations of workgroups are unique. */
for (subrec = FIRST_SUBNET; subrec && (t == -1); subrec = NEXT_SUBNET_INCLUDING_UNICAST(subrec)) {
struct work_record *w;
for (w = subrec->workgrouplist; w && t == -1; w = w->next) {
if (strnequal(w->work_group, work->work_group, sizeof(nstring)-1))
t = w->token;
}
}
if (t == -1)
work->token = ++workgroup_count;
else
work->token = t;
/* No known local master browser as yet. */
*work->local_master_browser_name = '\0';
/* No known domain master browser as yet. */
*work->dmb_name.name = '\0';
zero_ip(&work->dmb_addr);
/* WfWg uses 01040b01 */
/* Win95 uses 01041501 */
/* NTAS uses ???????? */
work->ElectionCriterion = (MAINTAIN_LIST)|(BROWSER_ELECTION_VERSION<<8);
work->ElectionCriterion |= (lp_os_level() << 24);
if (lp_domain_master())
work->ElectionCriterion |= 0x80;
return work;
}
char *
netmap(char name[], char from[])
{
char nbuf[BUFSIZ], ret[BUFSIZ];
register char *cp, *oname;
if (debug) fprintf(stderr, "netmap(name '%s', from '%s')\n", name, from);
if (strlen(from) == 0)
return(name); /* "from" is empty - can't do anything */
if (strcmp(from, name) == 0)
return(name); /* "from" and "name" are the same, do nothing */
/*
* If the name contains an "@" or a "%", remove it and the host
* following it if that host is "known".
*/
if (any('@', name) || any('%', name))
return(arpafix(name, from));
/*
* If the sender contains a "@" or a "%", make "name" into an
* address on that host, on the presumption that it should
* really have read "name@from" when we received the message
* rather than just "name".
*/
if (any('@', from) || any('%', from))
return(unuucp(makeremote(name, from)));
if (value("onehop") && (cp = strchr(name, '!')) && cp > name) {
/*
* "onehop" is set, meaning all machines are one UUCP
* hop away (fat chance, in this day and age), and "name"
* is a UUCP path rather than just a name. Leave it alone.
*/
nstrcpy(nbuf, sizeof (nbuf), name);
} else {
from = tackon(host, from);
*strrchr(from, '!') = 0;
name = tackon(lasthost(from), name);
while (((cp = lasthost(from)) != 0) && ishost(cp, name)) {
oname = name;
name = strchr(name, '!') + 1;
if (cp == from) {
from[strlen(from)] = '!';
if (value("mustbang") && !strchr(name, '!'))
name = oname;
return(unuucp(name));
}
*--cp = 0;
}
from[strlen(from)] = '!';
from = strchr(from, '!') + 1;
snprintf(nbuf, sizeof (nbuf), "%s!%s", from, name);
}
if (debug) fprintf(stderr, "before optim, nbuf '%s'\n", name);
#ifdef OPTIM
if ((cp = value("conv"))==NOSTR || strcmp(cp, "optimize") != 0)
nstrcpy(ret, sizeof (ret), nbuf);
else
optim(nbuf, ret);
#else
nstrcpy(ret, sizeof (ret), nbuf);
#endif /* OPTIM */
if (debug) fprintf(stderr, "after optim, nbuf '%s', ret '%s'\n", nbuf, ret);
cp = ret;
if (debug) fprintf(stderr, "wind up with '%s'\n", name);
if (!icequal(name, cp))
return(unuucp((char *) savestr(cp)));
return(unuucp(name));
}
// ////////////////////////////////////////////////////////////////////////////
void ParseFromString(const char *in_date, time_t &out_secs,
long &out_fractional, long fractional_places)
{
if (in_date == NULL)
ThrowInvalidArgument("Specified date string pointer is 'NULL'.");
try {
size_t date_length = strlen(in_date);
char date_buffer[Length_TimeSpec + 9 + 1];
if (date_length < 8)
ThrowInvalidArgument("Unknown date format.");
if (date_length == 8) {
char *end_ptr;
strtoul(in_date, &end_ptr, 10);
if (end_ptr != (in_date + 8))
ThrowInvalidArgument("Invalid undelimited date string --- "
"only numeric characters are valid.");
strcat(nstrcat(strcat(nstrcat(strcat(nstrcpy(date_buffer, in_date, 4),
"-"), in_date + 4, 2), "-"), in_date + 6, 2),
" 00:00:00.000000000");
ParseFromString_Basic(date_buffer, out_secs, out_fractional,
fractional_places);
}
else {
if ((!isdigit(in_date[0])) || (!isdigit(in_date[1])) ||
(!isdigit(in_date[2])) || (!isdigit(in_date[3])) ||
(!isdigit(in_date[5])) || (!isdigit(in_date[6])) ||
(!isdigit(in_date[8])) || (!isdigit(in_date[9])))
ThrowInvalidArgument("Invalid delimited date string --- "
"expected format for date portion is 'yyyy-mm-dd'.");
if (((in_date[4] != '-') && (in_date[4] != '/')) ||
((in_date[7] != '-') && (in_date[7] != '/')))
ThrowInvalidArgument("Invalid delimited date string --- "
"expected format for date portion is 'yyyy-mm-dd'.");
if (date_length == 10) {
strcat(strcpy(date_buffer, in_date), " 00:00:00.000000000");
ParseFromString_Basic(date_buffer, out_secs, out_fractional,
fractional_places);
}
else if (date_length <= Length_TimeSpec) {
if (((date_length < 20) && (date_length != 13) &&
(date_length != 16) && (date_length != 19)))
ThrowInvalidArgument("Unknown date format.");
if (((in_date[10] != ' ') && (in_date[10] != '.')) ||
(!isdigit(in_date[11])) || (!isdigit(in_date[12])))
ThrowInvalidArgument("Invalid delimited date/time string.");
if (date_length == 13)
ParseFromString_Basic(strcat(strcpy(date_buffer, in_date),
":00:00.000000000"), out_secs, out_fractional,
fractional_places);
else {
if (((in_date[13] != ':') && (in_date[13] != '.')) ||
(!isdigit(in_date[14])) || (!isdigit(in_date[15])))
ThrowInvalidArgument("Invalid delimited date/time string.");
if (date_length == 16)
ParseFromString_Basic(strcat(strcpy(date_buffer, in_date),
":00.000000000"), out_secs, out_fractional,
fractional_places);
else {
if (((in_date[16] != ':') && (in_date[16] != '.')) ||
(!isdigit(in_date[17])) || (!isdigit(in_date[18])))
ThrowInvalidArgument("Invalid delimited date/time string.");
else if (date_length == 19)
ParseFromString_Basic(strcat(strcpy(date_buffer, in_date),
".000000000"), out_secs, out_fractional,
fractional_places);
else if (in_date[19] != '.')
ThrowInvalidArgument("Invalid delimited date/time string.");
else
ParseFromString_Basic(nstrcat(strcpy(date_buffer, in_date),
"000000000", Length_TimeSpec - date_length), out_secs,
out_fractional, fractional_places);
}
}
}
else
ThrowInvalidArgument("Date/time string length exceeds maximum "
"permissible (" + AnyToString(Length_TimeSpec) +
" characters).");
}
}
catch (const std::exception &except) {
Rethrow(except, "Unable to parse date/time string '" +
std::string(in_date) + "': " + std::string(except.what()));
}
}
