ooh323c: Fix gcc 4.6.3 compiler warnings.
[asterisk/asterisk.git] / addons / ooh323c / src / ooTimer.c
1 /*
2  * Copyright (C) 2004-2005 by Objective Systems, Inc.
3  *
4  * This software is furnished under an open source license and may be 
5  * used and copied only in accordance with the terms of this license. 
6  * The text of the license may generally be found in the root 
7  * directory of this installation in the LICENSE.txt file.  It 
8  * can also be viewed online at the following URL:
9  *
10  *   http://www.obj-sys.com/open/license.html
11  *
12  * Any redistributions of this file including modified versions must 
13  * maintain this copyright notice.
14  *
15  *****************************************************************************/
16
17 #include "asterisk.h"
18 #include "asterisk/lock.h"
19
20 #include "ooDateTime.h"
21 #include "ooTimer.h"
22 #include "ootrace.h"
23
24 #define USECS_IN_SECS 1000000
25 #define NSECS_IN_USECS 1000
26
27 #ifndef MICROSEC
28 #define MICROSEC USECS_IN_SECS
29 #endif
30
31 /**
32  * This is a timer list used by test application chansetup only. 
33  */
34
35 DList g_TimerList;
36
37 OOTimer* ooTimerCreate 
38 (OOCTXT* pctxt, DList *pList, OOTimerCbFunc cb, OOUINT32 deltaSecs, void *data, 
39  OOBOOL reRegister)
40 {
41    OOTimer* pTimer = (OOTimer*) memAlloc (pctxt, sizeof(OOTimer));
42    if (0 == pTimer) return 0;
43
44    memset (pTimer, 0, (sizeof(OOTimer)));
45    pTimer->timeoutCB = cb;
46    pTimer->cbData = data;
47    pTimer->reRegister = reRegister;
48    pTimer->timeout.tv_sec  = deltaSecs;
49    pTimer->timeout.tv_usec = 0;
50
51    /* Compute the absolute time at which this timer should expire */
52
53    ooTimerComputeExpireTime (pTimer);
54
55    /* Insert this timer into the complete list */
56    if(pList)
57       ooTimerInsertEntry (pctxt, pList, pTimer);
58    else
59       ooTimerInsertEntry (pctxt, &g_TimerList, pTimer);
60
61    return pTimer;
62 }
63
64 void ooTimerComputeExpireTime (OOTimer* pTimer)
65 {
66    struct timeval tv;
67    ooGetTimeOfDay (&tv, 0);
68
69    /* Compute delta time to expiration */
70
71    pTimer->expireTime.tv_usec = tv.tv_usec + pTimer->timeout.tv_usec;
72    pTimer->expireTime.tv_sec  = tv.tv_sec  + pTimer->timeout.tv_sec;
73
74    while (pTimer->expireTime.tv_usec >= MICROSEC) {
75       pTimer->expireTime.tv_usec -= MICROSEC;
76       pTimer->expireTime.tv_sec++;
77    }
78 }
79
80 void ooTimerDelete (OOCTXT* pctxt, DList *pList, OOTimer* pTimer)
81 {
82    dListFindAndRemove (pctxt, pList, pTimer);
83    memFreePtr (pctxt, pTimer);
84 }
85
86 OOBOOL ooTimerExpired (OOTimer* pTimer)
87 {
88    struct timeval tvstr;
89    ooGetTimeOfDay (&tvstr, 0);
90
91    if (tvstr.tv_sec > pTimer->expireTime.tv_sec)
92       return TRUE;
93
94    if ((tvstr.tv_sec == pTimer->expireTime.tv_sec) &&
95        (tvstr.tv_usec > pTimer->expireTime.tv_usec))
96       return TRUE;
97
98    return FALSE;
99 }
100
101 void ooTimerFireExpired (OOCTXT* pctxt, DList *pList)
102 {
103    OOTimer* pTimer;
104
105    while (pList->count > 0) {
106       pTimer = (OOTimer*) pList->head->data;
107
108       if (ooTimerExpired (pTimer)) {
109          /*
110           * Re-register before calling callback function in case it is
111           * a long duration callback.                                   
112           */
113          if (pTimer->reRegister) ooTimerReset (pctxt, pList, pTimer);
114
115          (*pTimer->timeoutCB)(pTimer->cbData);
116
117          if (!pTimer->reRegister) {
118             ooTimerDelete (pctxt, pList, pTimer);
119          }
120       }
121       else break;
122    }
123 }
124
125 int ooTimerInsertEntry (OOCTXT* pctxt, DList *pList, OOTimer* pTimer)
126 {  DListNode* pNode;
127    OOTimer* p;
128    int i = 0;
129
130    for (pNode = pList->head; pNode != 0; pNode = pNode->next) {
131       p = (OOTimer*) pNode->data;
132       if (pTimer->expireTime.tv_sec  <  p->expireTime.tv_sec) break;
133       if (pTimer->expireTime.tv_sec  == p->expireTime.tv_sec &&
134           pTimer->expireTime.tv_usec <= p->expireTime.tv_usec) break;
135       i++;
136    }
137
138    dListInsertBefore (pctxt, pList, pNode, pTimer);
139
140    return i;
141 }
142
143 struct timeval* ooTimerNextTimeout (DList *pList, struct timeval* ptimeout)
144 {
145    OOTimer* ptimer;
146    struct timeval tvstr;
147
148    if (pList->count == 0) return 0;
149    ptimer = (OOTimer*) pList->head->data;
150
151    ooGetTimeOfDay (&tvstr, 0);
152
153    ptimeout->tv_sec = 
154       OOMAX ((int) 0, (int) (ptimer->expireTime.tv_sec - tvstr.tv_sec));   
155
156    ptimeout->tv_usec = ptimer->expireTime.tv_usec - tvstr.tv_usec;
157
158    while (ptimeout->tv_usec < 0) {
159       ptimeout->tv_sec--;
160       ptimeout->tv_usec += USECS_IN_SECS;
161    }
162
163    if (ptimeout->tv_sec < 0)
164       ptimeout->tv_sec = ptimeout->tv_usec = 0;
165
166    return (ptimeout);
167 }
168
169 /* 
170  * Reregister a timer entry.  This function is responsible for moving
171  * the current pointer in the timer list to the next element to be
172  * processed..
173  */
174 void ooTimerReset (OOCTXT* pctxt, DList *pList, OOTimer* pTimer)
175 {
176    if (pTimer->reRegister) {
177       dListFindAndRemove (pctxt, pList, pTimer);
178       ooTimerComputeExpireTime (pTimer);
179       ooTimerInsertEntry (pctxt, pList, pTimer);
180    }
181    else
182       ooTimerDelete (pctxt, pList, pTimer);
183 }
184
185 int ooCompareTimeouts(struct timeval *to1, struct timeval *to2)
186 {
187
188    if(to1->tv_sec > to2->tv_sec)   return 1;
189    if(to1->tv_sec < to2->tv_sec)   return -1;
190
191    if(to1->tv_usec > to2->tv_usec)   return 1;
192    if(to1->tv_usec < to2->tv_usec)   return -1;
193
194    return 0;
195 }