"Fossies" - the Fresh Open Source Software Archive

Member "apr-1.7.0/time/unix/time.c" (3 Aug 2006, 10501 Bytes) of package /linux/www/apr-1.7.0.tar.bz2:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "time.c" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 1.6.5_vs_1.7.0.

    1 /* Licensed to the Apache Software Foundation (ASF) under one or more
    2  * contributor license agreements.  See the NOTICE file distributed with
    3  * this work for additional information regarding copyright ownership.
    4  * The ASF licenses this file to You under the Apache License, Version 2.0
    5  * (the "License"); you may not use this file except in compliance with
    6  * the License.  You may obtain a copy of the License at
    7  *
    8  *     http://www.apache.org/licenses/LICENSE-2.0
    9  *
   10  * Unless required by applicable law or agreed to in writing, software
   11  * distributed under the License is distributed on an "AS IS" BASIS,
   12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   13  * See the License for the specific language governing permissions and
   14  * limitations under the License.
   15  */
   16 
   17 #include "apr_portable.h"
   18 #include "apr_time.h"
   19 #include "apr_lib.h"
   20 #include "apr_private.h"
   21 #include "apr_strings.h"
   22 
   23 /* private APR headers */
   24 #include "apr_arch_internal_time.h"
   25 
   26 /* System Headers required for time library */
   27 #if APR_HAVE_SYS_TIME_H
   28 #include <sys/time.h>
   29 #endif
   30 #if APR_HAVE_UNISTD_H
   31 #include <unistd.h>
   32 #endif
   33 #ifdef HAVE_TIME_H
   34 #include <time.h>
   35 #endif
   36 /* End System Headers */
   37 
   38 #if !defined(HAVE_STRUCT_TM_TM_GMTOFF) && !defined(HAVE_STRUCT_TM___TM_GMTOFF)
   39 static apr_int32_t server_gmt_offset;
   40 #define NO_GMTOFF_IN_STRUCT_TM
   41 #endif          
   42 
   43 static apr_int32_t get_offset(struct tm *tm)
   44 {
   45 #if defined(HAVE_STRUCT_TM_TM_GMTOFF)
   46     return tm->tm_gmtoff;
   47 #elif defined(HAVE_STRUCT_TM___TM_GMTOFF)
   48     return tm->__tm_gmtoff;
   49 #else
   50 #ifdef NETWARE
   51     /* Need to adjust the global variable each time otherwise
   52         the web server would have to be restarted when daylight
   53         savings changes.
   54     */
   55     if (daylightOnOff) {
   56         return server_gmt_offset + daylightOffset;
   57     }
   58 #else
   59     if (tm->tm_isdst)
   60         return server_gmt_offset + 3600;
   61 #endif
   62     return server_gmt_offset;
   63 #endif
   64 }
   65 
   66 APR_DECLARE(apr_status_t) apr_time_ansi_put(apr_time_t *result,
   67                                             time_t input)
   68 {
   69     *result = (apr_time_t)input * APR_USEC_PER_SEC;
   70     return APR_SUCCESS;
   71 }
   72 
   73 /* NB NB NB NB This returns GMT!!!!!!!!!! */
   74 APR_DECLARE(apr_time_t) apr_time_now(void)
   75 {
   76     struct timeval tv;
   77     gettimeofday(&tv, NULL);
   78     return tv.tv_sec * APR_USEC_PER_SEC + tv.tv_usec;
   79 }
   80 
   81 static void explode_time(apr_time_exp_t *xt, apr_time_t t,
   82                          apr_int32_t offset, int use_localtime)
   83 {
   84     struct tm tm;
   85     time_t tt = (t / APR_USEC_PER_SEC) + offset;
   86     xt->tm_usec = t % APR_USEC_PER_SEC;
   87 
   88 #if APR_HAS_THREADS && defined (_POSIX_THREAD_SAFE_FUNCTIONS)
   89     if (use_localtime)
   90         localtime_r(&tt, &tm);
   91     else
   92         gmtime_r(&tt, &tm);
   93 #else
   94     if (use_localtime)
   95         tm = *localtime(&tt);
   96     else
   97         tm = *gmtime(&tt);
   98 #endif
   99 
  100     xt->tm_sec  = tm.tm_sec;
  101     xt->tm_min  = tm.tm_min;
  102     xt->tm_hour = tm.tm_hour;
  103     xt->tm_mday = tm.tm_mday;
  104     xt->tm_mon  = tm.tm_mon;
  105     xt->tm_year = tm.tm_year;
  106     xt->tm_wday = tm.tm_wday;
  107     xt->tm_yday = tm.tm_yday;
  108     xt->tm_isdst = tm.tm_isdst;
  109     xt->tm_gmtoff = get_offset(&tm);
  110 }
  111 
  112 APR_DECLARE(apr_status_t) apr_time_exp_tz(apr_time_exp_t *result,
  113                                           apr_time_t input, apr_int32_t offs)
  114 {
  115     explode_time(result, input, offs, 0);
  116     result->tm_gmtoff = offs;
  117     return APR_SUCCESS;
  118 }
  119 
  120 APR_DECLARE(apr_status_t) apr_time_exp_gmt(apr_time_exp_t *result,
  121                                            apr_time_t input)
  122 {
  123     return apr_time_exp_tz(result, input, 0);
  124 }
  125 
  126 APR_DECLARE(apr_status_t) apr_time_exp_lt(apr_time_exp_t *result,
  127                                                 apr_time_t input)
  128 {
  129 #if defined(__EMX__)
  130     /* EMX gcc (OS/2) has a timezone global we can use */
  131     return apr_time_exp_tz(result, input, -timezone);
  132 #else
  133     explode_time(result, input, 0, 1);
  134     return APR_SUCCESS;
  135 #endif /* __EMX__ */
  136 }
  137 
  138 APR_DECLARE(apr_status_t) apr_time_exp_get(apr_time_t *t, apr_time_exp_t *xt)
  139 {
  140     apr_time_t year = xt->tm_year;
  141     apr_time_t days;
  142     static const int dayoffset[12] =
  143     {306, 337, 0, 31, 61, 92, 122, 153, 184, 214, 245, 275};
  144 
  145     /* shift new year to 1st March in order to make leap year calc easy */
  146 
  147     if (xt->tm_mon < 2)
  148         year--;
  149 
  150     /* Find number of days since 1st March 1900 (in the Gregorian calendar). */
  151 
  152     days = year * 365 + year / 4 - year / 100 + (year / 100 + 3) / 4;
  153     days += dayoffset[xt->tm_mon] + xt->tm_mday - 1;
  154     days -= 25508;              /* 1 jan 1970 is 25508 days since 1 mar 1900 */
  155     days = ((days * 24 + xt->tm_hour) * 60 + xt->tm_min) * 60 + xt->tm_sec;
  156 
  157     if (days < 0) {
  158         return APR_EBADDATE;
  159     }
  160     *t = days * APR_USEC_PER_SEC + xt->tm_usec;
  161     return APR_SUCCESS;
  162 }
  163 
  164 APR_DECLARE(apr_status_t) apr_time_exp_gmt_get(apr_time_t *t, 
  165                                                apr_time_exp_t *xt)
  166 {
  167     apr_status_t status = apr_time_exp_get(t, xt);
  168     if (status == APR_SUCCESS)
  169         *t -= (apr_time_t) xt->tm_gmtoff * APR_USEC_PER_SEC;
  170     return status;
  171 }
  172 
  173 APR_DECLARE(apr_status_t) apr_os_imp_time_get(apr_os_imp_time_t **ostime,
  174                                               apr_time_t *aprtime)
  175 {
  176     (*ostime)->tv_usec = *aprtime % APR_USEC_PER_SEC;
  177     (*ostime)->tv_sec = *aprtime / APR_USEC_PER_SEC;
  178     return APR_SUCCESS;
  179 }
  180 
  181 APR_DECLARE(apr_status_t) apr_os_exp_time_get(apr_os_exp_time_t **ostime,
  182                                               apr_time_exp_t *aprtime)
  183 {
  184     (*ostime)->tm_sec  = aprtime->tm_sec;
  185     (*ostime)->tm_min  = aprtime->tm_min;
  186     (*ostime)->tm_hour = aprtime->tm_hour;
  187     (*ostime)->tm_mday = aprtime->tm_mday;
  188     (*ostime)->tm_mon  = aprtime->tm_mon;
  189     (*ostime)->tm_year = aprtime->tm_year;
  190     (*ostime)->tm_wday = aprtime->tm_wday;
  191     (*ostime)->tm_yday = aprtime->tm_yday;
  192     (*ostime)->tm_isdst = aprtime->tm_isdst;
  193 
  194 #if defined(HAVE_STRUCT_TM_TM_GMTOFF)
  195     (*ostime)->tm_gmtoff = aprtime->tm_gmtoff;
  196 #elif defined(HAVE_STRUCT_TM___TM_GMTOFF)
  197     (*ostime)->__tm_gmtoff = aprtime->tm_gmtoff;
  198 #endif
  199 
  200     return APR_SUCCESS;
  201 }
  202 
  203 APR_DECLARE(apr_status_t) apr_os_imp_time_put(apr_time_t *aprtime,
  204                                               apr_os_imp_time_t **ostime,
  205                                               apr_pool_t *cont)
  206 {
  207     *aprtime = (*ostime)->tv_sec * APR_USEC_PER_SEC + (*ostime)->tv_usec;
  208     return APR_SUCCESS;
  209 }
  210 
  211 APR_DECLARE(apr_status_t) apr_os_exp_time_put(apr_time_exp_t *aprtime,
  212                                               apr_os_exp_time_t **ostime,
  213                                               apr_pool_t *cont)
  214 {
  215     aprtime->tm_sec = (*ostime)->tm_sec;
  216     aprtime->tm_min = (*ostime)->tm_min;
  217     aprtime->tm_hour = (*ostime)->tm_hour;
  218     aprtime->tm_mday = (*ostime)->tm_mday;
  219     aprtime->tm_mon = (*ostime)->tm_mon;
  220     aprtime->tm_year = (*ostime)->tm_year;
  221     aprtime->tm_wday = (*ostime)->tm_wday;
  222     aprtime->tm_yday = (*ostime)->tm_yday;
  223     aprtime->tm_isdst = (*ostime)->tm_isdst;
  224 
  225 #if defined(HAVE_STRUCT_TM_TM_GMTOFF)
  226     aprtime->tm_gmtoff = (*ostime)->tm_gmtoff;
  227 #elif defined(HAVE_STRUCT_TM___TM_GMTOFF)
  228     aprtime->tm_gmtoff = (*ostime)->__tm_gmtoff;
  229 #endif
  230 
  231     return APR_SUCCESS;
  232 }
  233 
  234 APR_DECLARE(void) apr_sleep(apr_interval_time_t t)
  235 {
  236 #ifdef OS2
  237     DosSleep(t/1000);
  238 #elif defined(BEOS)
  239     snooze(t);
  240 #elif defined(NETWARE)
  241     delay(t/1000);
  242 #else
  243     struct timeval tv;
  244     tv.tv_usec = t % APR_USEC_PER_SEC;
  245     tv.tv_sec = t / APR_USEC_PER_SEC;
  246     select(0, NULL, NULL, NULL, &tv);
  247 #endif
  248 }
  249 
  250 #ifdef OS2
  251 APR_DECLARE(apr_status_t) apr_os2_time_to_apr_time(apr_time_t *result,
  252                                                    FDATE os2date,
  253                                                    FTIME os2time)
  254 {
  255   struct tm tmpdate;
  256 
  257   memset(&tmpdate, 0, sizeof(tmpdate));
  258   tmpdate.tm_hour  = os2time.hours;
  259   tmpdate.tm_min   = os2time.minutes;
  260   tmpdate.tm_sec   = os2time.twosecs * 2;
  261 
  262   tmpdate.tm_mday  = os2date.day;
  263   tmpdate.tm_mon   = os2date.month - 1;
  264   tmpdate.tm_year  = os2date.year + 80;
  265   tmpdate.tm_isdst = -1;
  266 
  267   *result = mktime(&tmpdate) * APR_USEC_PER_SEC;
  268   return APR_SUCCESS;
  269 }
  270 
  271 APR_DECLARE(apr_status_t) apr_apr_time_to_os2_time(FDATE *os2date,
  272                                                    FTIME *os2time,
  273                                                    apr_time_t aprtime)
  274 {
  275     time_t ansitime = aprtime / APR_USEC_PER_SEC;
  276     struct tm *lt;
  277     lt = localtime(&ansitime);
  278     os2time->hours    = lt->tm_hour;
  279     os2time->minutes  = lt->tm_min;
  280     os2time->twosecs  = lt->tm_sec / 2;
  281 
  282     os2date->day      = lt->tm_mday;
  283     os2date->month    = lt->tm_mon + 1;
  284     os2date->year     = lt->tm_year - 80;
  285     return APR_SUCCESS;
  286 }
  287 #endif
  288 
  289 #ifdef NETWARE
  290 APR_DECLARE(void) apr_netware_setup_time(void)
  291 {
  292     tzset();
  293     server_gmt_offset = -TZONE;
  294 }
  295 #else
  296 APR_DECLARE(void) apr_unix_setup_time(void)
  297 {
  298 #ifdef NO_GMTOFF_IN_STRUCT_TM
  299     /* Precompute the offset from GMT on systems where it's not
  300        in struct tm.
  301 
  302        Note: This offset is normalized to be independent of daylight
  303        savings time; if the calculation happens to be done in a
  304        time/place where a daylight savings adjustment is in effect,
  305        the returned offset has the same value that it would have
  306        in the same location if daylight savings were not in effect.
  307        The reason for this is that the returned offset can be
  308        applied to a past or future timestamp in explode_time(),
  309        so the DST adjustment obtained from the current time won't
  310        necessarily be applicable.
  311 
  312        mktime() is the inverse of localtime(); so, presumably,
  313        passing in a struct tm made by gmtime() let's us calculate
  314        the true GMT offset. However, there's a catch: if daylight
  315        savings is in effect, gmtime()will set the tm_isdst field
  316        and confuse mktime() into returning a time that's offset
  317        by one hour. In that case, we must adjust the calculated GMT
  318        offset.
  319 
  320      */
  321 
  322     struct timeval now;
  323     time_t t1, t2;
  324     struct tm t;
  325 
  326     gettimeofday(&now, NULL);
  327     t1 = now.tv_sec;
  328     t2 = 0;
  329 
  330 #if APR_HAS_THREADS && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
  331     gmtime_r(&t1, &t);
  332 #else
  333     t = *gmtime(&t1);
  334 #endif
  335     t.tm_isdst = 0; /* we know this GMT time isn't daylight-savings */
  336     t2 = mktime(&t);
  337     server_gmt_offset = (apr_int32_t) difftime(t1, t2);
  338 #endif /* NO_GMTOFF_IN_STRUCT_TM */
  339 }
  340 
  341 #endif
  342 
  343 /* A noop on all known Unix implementations */
  344 APR_DECLARE(void) apr_time_clock_hires(apr_pool_t *p)
  345 {
  346     return;
  347 }
  348 
  349