if (!opt.lfilename)
{
- opt.lfilename = unique_name (DEFAULT_LOGFILE);
+ opt.lfilename = unique_name (DEFAULT_LOGFILE, 0);
changedp = 1;
}
pid = fork ();
return size;
}
-/* Return a unique filename, given a prefix and count */
+/* stat file names named PREFIX.1, PREFIX.2, etc., until one that
+ doesn't exist is found. Return a freshly allocated copy of the
+ unused file name. */
+
static char *
-unique_name_1 (const char *fileprefix, int count)
+unique_name_1 (const char *prefix)
{
- char *filename;
+ int count = 1;
+ int plen = strlen (prefix);
+ char *template = (char *)alloca (plen + 1 + 24);
+ char *template_tail = template + plen;
- if (count)
- {
- filename = (char *)xmalloc (strlen (fileprefix) + numdigit (count) + 2);
- sprintf (filename, "%s.%d", fileprefix, count);
- }
- else
- filename = xstrdup (fileprefix);
+ memcpy (template, prefix, plen);
+ *template_tail++ = '.';
- if (!file_exists_p (filename))
- return filename;
- else
- {
- xfree (filename);
- return NULL;
- }
+ do
+ number_to_string (template_tail, count++);
+ while (file_exists_p (template));
+
+ return xstrdup (template);
}
-/* Return a unique file name, based on PREFIX. */
+/* Return a unique file name, based on FILE.
+
+ More precisely, if FILE doesn't exist, it is returned unmodified.
+ If not, FILE.1 is tried, then FILE.2, etc. The first FILE.<number>
+ file name that doesn't exist is returned.
+
+ The resulting file is not created, only verified that it didn't
+ exist at the point in time when the function was called.
+ Therefore, where security matters, don't rely that the file created
+ by this function exists until you open it with O_EXCL or
+ something.
+
+ If ALLOW_PASSTHROUGH is 0, it always returns a freshly allocated
+ string. Otherwise, it may return FILE if the file doesn't exist
+ (and therefore doesn't need changing). */
+
char *
-unique_name (const char *prefix)
+unique_name (const char *file, int allow_passthrough)
{
- char *file = NULL;
- int count = 0;
+ /* If the FILE itself doesn't exist, return it without
+ modification. */
+ if (!file_exists_p (file))
+ return allow_passthrough ? (char *)file : xstrdup (file);
- while (!file)
- file = unique_name_1 (prefix, count++);
- return file;
+ /* Otherwise, find a numeric suffix that results in unused file name
+ and return it. */
+ return unique_name_1 (file);
}
\f
/* Create DIRECTORY. If some of the pathname components of DIRECTORY
/* The most recent elapsed time, calculated by wtimer_elapsed().
Measured in milliseconds. */
- long elapsed_last;
+ double elapsed_last;
/* Approximately, the time elapsed between the true start of the
measurement and the time represented by START. */
- long elapsed_pre_start;
+ double elapsed_pre_start;
};
/* Allocate a timer. It is not legal to do anything with a freshly
#endif
#ifdef TIMER_WINDOWS
+ /* We use GetSystemTime to get the elapsed time. MSDN warns that
+ system clock adjustments can skew the output of GetSystemTime
+ when used as a timer and gives preference to GetTickCount and
+ high-resolution timers. But GetTickCount can overflow, and hires
+ timers are typically used for profiling, not for regular time
+ measurement. Since we handle clock skew anyway, we just use
+ GetSystemTime. */
FILETIME ft;
SYSTEMTIME st;
GetSystemTime (&st);
+
+ /* As recommended by MSDN, we convert SYSTEMTIME to FILETIME, copy
+ FILETIME to ULARGE_INTEGER, and use regular 64-bit integer
+ arithmetic on that. */
SystemTimeToFileTime (&st, &ft);
wst->HighPart = ft.dwHighDateTime;
wst->LowPart = ft.dwLowDateTime;
wt->elapsed_pre_start = 0;
}
-static long
+static double
wtimer_sys_diff (wget_sys_time *wst1, wget_sys_time *wst2)
{
#ifdef TIMER_GETTIMEOFDAY
- return ((wst1->tv_sec - wst2->tv_sec) * 1000
- + (wst1->tv_usec - wst2->tv_usec) / 1000);
+ return ((double)(wst1->tv_sec - wst2->tv_sec) * 1000
+ + (double)(wst1->tv_usec - wst2->tv_usec) / 1000);
#endif
#ifdef TIMER_TIME
#endif
#ifdef WINDOWS
- return (long)(wst1->QuadPart - wst2->QuadPart) / 10000;
+ /* VC++ 6 doesn't support direct cast of uint64 to double. To work
+ around this, we subtract, then convert to signed, then finally to
+ double. */
+ return (double)(signed __int64)(wst1->QuadPart - wst2->QuadPart) / 10000;
#endif
}
/* Return the number of milliseconds elapsed since the timer was last
reset. It is allowed to call this function more than once to get
- increasingly higher elapsed values. */
+ increasingly higher elapsed values. These timers handle clock
+ skew. */
-long
+double
wtimer_elapsed (struct wget_timer *wt)
{
wget_sys_time now;
- long elapsed;
+ double elapsed;
wtimer_sys_set (&now);
elapsed = wt->elapsed_pre_start + wtimer_sys_diff (&now, &wt->start);
return elapsed;
}
-/* Return the assessed granularity of the timer implementation. This
- is important for certain code that tries to deal with "zero" time
- intervals. */
+/* Return the assessed granularity of the timer implementation, in
+ milliseconds. This is used by code that tries to substitute a
+ better value for timers that have returned zero. */
-long
+double
wtimer_granularity (void)
{
#ifdef TIMER_GETTIMEOFDAY
- /* Granularity of gettimeofday is hugely architecture-dependent.
- However, it appears that on modern machines it is better than
- 1ms. */
- return 1;
+ /* Granularity of gettimeofday varies wildly between architectures.
+ However, it appears that on modern machines it tends to be better
+ than 1ms. Assume 100 usecs. (Perhaps the configure process
+ could actually measure this?) */
+ return 0.1;
#endif
#ifdef TIMER_TIME
#endif
#ifdef TIMER_WINDOWS
- /* ? */
+ /* According to MSDN, GetSystemTime returns a broken-down time
+ structure the smallest member of which are milliseconds. */
return 1;
#endif
}