Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
maintidi.c
Go to the documentation of this file.
1 /*
2  *
3  Copyright (c) Eicon Networks, 2000.
4  *
5  This source file is supplied for the use with
6  Eicon Networks range of DIVA Server Adapters.
7  *
8  Eicon File Revision : 1.9
9  *
10  This program is free software; you can redistribute it and/or modify
11  it under the terms of the GNU General Public License as published by
12  the Free Software Foundation; either version 2, or (at your option)
13  any later version.
14  *
15  This program is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY OF ANY KIND WHATSOEVER INCLUDING ANY
17  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
18  See the GNU General Public License for more details.
19  *
20  You should have received a copy of the GNU General Public License
21  along with this program; if not, write to the Free Software
22  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23  *
24  */
25 #include "platform.h"
26 #include "kst_ifc.h"
27 #include "di_defs.h"
28 #include "maintidi.h"
29 #include "pc.h"
30 #include "man_defs.h"
31 
32 
33 extern void diva_mnt_internal_dprintf(dword drv_id, dword type, char *p, ...);
34 
35 #define MODEM_PARSE_ENTRIES 16 /* amount of variables of interest */
36 #define FAX_PARSE_ENTRIES 12 /* amount of variables of interest */
37 #define LINE_PARSE_ENTRIES 15 /* amount of variables of interest */
38 #define STAT_PARSE_ENTRIES 70 /* amount of variables of interest */
39 
40 /*
41  LOCAL FUNCTIONS
42 */
43 static int DivaSTraceLibraryStart(void *hLib);
44 static int DivaSTraceLibraryStop(void *hLib);
45 static int SuperTraceLibraryFinit(void *hLib);
46 static void *SuperTraceGetHandle(void *hLib);
47 static int SuperTraceMessageInput(void *hLib);
48 static int SuperTraceSetAudioTap(void *hLib, int Channel, int on);
49 static int SuperTraceSetBChannel(void *hLib, int Channel, int on);
50 static int SuperTraceSetDChannel(void *hLib, int on);
51 static int SuperTraceSetInfo(void *hLib, int on);
52 static int SuperTraceClearCall(void *hLib, int Channel);
53 static int SuperTraceGetOutgoingCallStatistics(void *hLib);
54 static int SuperTraceGetIncomingCallStatistics(void *hLib);
55 static int SuperTraceGetModemStatistics(void *hLib);
56 static int SuperTraceGetFaxStatistics(void *hLib);
57 static int SuperTraceGetBLayer1Statistics(void *hLib);
58 static int SuperTraceGetBLayer2Statistics(void *hLib);
59 static int SuperTraceGetDLayer1Statistics(void *hLib);
60 static int SuperTraceGetDLayer2Statistics(void *hLib);
61 
62 /*
63  LOCAL FUNCTIONS
64 */
65 static int ScheduleNextTraceRequest(diva_strace_context_t *pLib);
66 static int process_idi_event(diva_strace_context_t *pLib,
67  diva_man_var_header_t *pVar);
68 static int process_idi_info(diva_strace_context_t *pLib,
69  diva_man_var_header_t *pVar);
70 static int diva_modem_event(diva_strace_context_t *pLib, int Channel);
71 static int diva_fax_event(diva_strace_context_t *pLib, int Channel);
72 static int diva_line_event(diva_strace_context_t *pLib, int Channel);
73 static int diva_modem_info(diva_strace_context_t *pLib,
74  int Channel,
75  diva_man_var_header_t *pVar);
76 static int diva_fax_info(diva_strace_context_t *pLib,
77  int Channel,
78  diva_man_var_header_t *pVar);
79 static int diva_line_info(diva_strace_context_t *pLib,
80  int Channel,
81  diva_man_var_header_t *pVar);
82 static int diva_ifc_statistics(diva_strace_context_t *pLib,
83  diva_man_var_header_t *pVar);
84 static diva_man_var_header_t *get_next_var(diva_man_var_header_t *pVar);
85 static diva_man_var_header_t *find_var(diva_man_var_header_t *pVar,
86  const char *name);
87 static int diva_strace_read_int(diva_man_var_header_t *pVar, int *var);
88 static int diva_strace_read_uint(diva_man_var_header_t *pVar, dword *var);
89 static int diva_strace_read_asz(diva_man_var_header_t *pVar, char *var);
90 static int diva_strace_read_asc(diva_man_var_header_t *pVar, char *var);
91 static int diva_strace_read_ie(diva_man_var_header_t *pVar,
92  diva_trace_ie_t *var);
93 static void diva_create_parse_table(diva_strace_context_t *pLib);
94 static void diva_trace_error(diva_strace_context_t *pLib,
95  int error, const char *file, int line);
96 static void diva_trace_notify_user(diva_strace_context_t *pLib,
97  int Channel,
98  int notify_subject);
99 static int diva_trace_read_variable(diva_man_var_header_t *pVar,
100  void *variable);
101 
102 /*
103  Initialize the library and return context
104  of the created trace object that will represent
105  the IDI adapter.
106  Return 0 on error.
107 */
108 diva_strace_library_interface_t *DivaSTraceLibraryCreateInstance(int Adapter,
109  const diva_trace_library_user_interface_t *user_proc,
110  byte *pmem) {
111  diva_strace_context_t *pLib = (diva_strace_context_t *)pmem;
112  int i;
113 
114  if (!pLib) {
115  return NULL;
116  }
117 
118  pmem += sizeof(*pLib);
119  memset(pLib, 0x00, sizeof(*pLib));
120 
121  pLib->Adapter = Adapter;
122 
123  /*
124  Set up Library Interface
125  */
126  pLib->instance.hLib = pLib;
127  pLib->instance.DivaSTraceLibraryStart = DivaSTraceLibraryStart;
128  pLib->instance.DivaSTraceLibraryStop = DivaSTraceLibraryStop;
129  pLib->instance.DivaSTraceLibraryFinit = SuperTraceLibraryFinit;
130  pLib->instance.DivaSTraceMessageInput = SuperTraceMessageInput;
131  pLib->instance.DivaSTraceGetHandle = SuperTraceGetHandle;
132  pLib->instance.DivaSTraceSetAudioTap = SuperTraceSetAudioTap;
133  pLib->instance.DivaSTraceSetBChannel = SuperTraceSetBChannel;
134  pLib->instance.DivaSTraceSetDChannel = SuperTraceSetDChannel;
135  pLib->instance.DivaSTraceSetInfo = SuperTraceSetInfo;
136  pLib->instance.DivaSTraceGetOutgoingCallStatistics = \
137  SuperTraceGetOutgoingCallStatistics;
138  pLib->instance.DivaSTraceGetIncomingCallStatistics = \
139  SuperTraceGetIncomingCallStatistics;
140  pLib->instance.DivaSTraceGetModemStatistics = \
141  SuperTraceGetModemStatistics;
142  pLib->instance.DivaSTraceGetFaxStatistics = \
143  SuperTraceGetFaxStatistics;
144  pLib->instance.DivaSTraceGetBLayer1Statistics = \
145  SuperTraceGetBLayer1Statistics;
146  pLib->instance.DivaSTraceGetBLayer2Statistics = \
147  SuperTraceGetBLayer2Statistics;
148  pLib->instance.DivaSTraceGetDLayer1Statistics = \
149  SuperTraceGetDLayer1Statistics;
150  pLib->instance.DivaSTraceGetDLayer2Statistics = \
151  SuperTraceGetDLayer2Statistics;
152  pLib->instance.DivaSTraceClearCall = SuperTraceClearCall;
153 
154 
155  if (user_proc) {
156  pLib->user_proc_table.user_context = user_proc->user_context;
157  pLib->user_proc_table.notify_proc = user_proc->notify_proc;
158  pLib->user_proc_table.trace_proc = user_proc->trace_proc;
159  pLib->user_proc_table.error_notify_proc = user_proc->error_notify_proc;
160  }
161 
162  if (!(pLib->hAdapter = SuperTraceOpenAdapter(Adapter))) {
163  diva_mnt_internal_dprintf(0, DLI_ERR, "Can not open XDI adapter");
164  return NULL;
165  }
166  pLib->Channels = SuperTraceGetNumberOfChannels(pLib->hAdapter);
167 
168  /*
169  Calculate amount of parte table entites necessary to translate
170  information from all events of onterest
171  */
172  pLib->parse_entries = (MODEM_PARSE_ENTRIES + FAX_PARSE_ENTRIES + \
173  STAT_PARSE_ENTRIES + \
174  LINE_PARSE_ENTRIES + 1) * pLib->Channels;
175  pLib->parse_table = (diva_strace_path2action_t *)pmem;
176 
177  for (i = 0; i < 30; i++) {
178  pLib->lines[i].pInterface = &pLib->Interface;
179  pLib->lines[i].pInterfaceStat = &pLib->InterfaceStat;
180  }
181 
182  pLib->e.R = &pLib->RData;
183 
184  pLib->req_busy = 1;
185  pLib->rc_ok = ASSIGN_OK;
186 
187  diva_create_parse_table(pLib);
188 
189  return ((diva_strace_library_interface_t *)pLib);
190 }
191 
192 static int DivaSTraceLibraryStart(void *hLib) {
193  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
194 
195  return (SuperTraceASSIGN(pLib->hAdapter, pLib->buffer));
196 }
197 
198 /*
199  Return (-1) on error
200  Return (0) if was initiated or pending
201  Return (1) if removal is complete
202 */
203 static int DivaSTraceLibraryStop(void *hLib) {
204  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
205 
206  if (!pLib->e.Id) { /* Was never started/assigned */
207  return (1);
208  }
209 
210  switch (pLib->removal_state) {
211  case 0:
212  pLib->removal_state = 1;
213  ScheduleNextTraceRequest(pLib);
214  break;
215 
216  case 3:
217  return (1);
218  }
219 
220  return (0);
221 }
222 
223 static int SuperTraceLibraryFinit(void *hLib) {
224  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
225  if (pLib) {
226  if (pLib->hAdapter) {
227  SuperTraceCloseAdapter(pLib->hAdapter);
228  }
229  return (0);
230  }
231  return (-1);
232 }
233 
234 static void *SuperTraceGetHandle(void *hLib) {
235  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
236 
237  return (&pLib->e);
238 }
239 
240 /*
241  After library handle object is gone in signaled state
242  this function should be called and will pick up incoming
243  IDI messages (return codes and indications).
244 */
245 static int SuperTraceMessageInput(void *hLib) {
246  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
247  int ret = 0;
248  byte Rc, Ind;
249 
250  if (pLib->e.complete == 255) {
251  /*
252  Process return code
253  */
254  pLib->req_busy = 0;
255  Rc = pLib->e.Rc;
256  pLib->e.Rc = 0;
257 
258  if (pLib->removal_state == 2) {
259  pLib->removal_state = 3;
260  return (0);
261  }
262 
263  if (Rc != pLib->rc_ok) {
264  int ignore = 0;
265  /*
266  Auto-detect amount of events/channels and features
267  */
268  if (pLib->general_b_ch_event == 1) {
269  pLib->general_b_ch_event = 2;
270  ignore = 1;
271  } else if (pLib->general_fax_event == 1) {
272  pLib->general_fax_event = 2;
273  ignore = 1;
274  } else if (pLib->general_mdm_event == 1) {
275  pLib->general_mdm_event = 2;
276  ignore = 1;
277  } else if ((pLib->ChannelsTraceActive < pLib->Channels) && pLib->ChannelsTraceActive) {
278  pLib->ChannelsTraceActive = pLib->Channels;
279  ignore = 1;
280  } else if (pLib->ModemTraceActive < pLib->Channels) {
281  pLib->ModemTraceActive = pLib->Channels;
282  ignore = 1;
283  } else if (pLib->FaxTraceActive < pLib->Channels) {
284  pLib->FaxTraceActive = pLib->Channels;
285  ignore = 1;
286  } else if (pLib->audio_trace_init == 2) {
287  ignore = 1;
288  pLib->audio_trace_init = 1;
289  } else if (pLib->eye_pattern_pending) {
290  pLib->eye_pattern_pending = 0;
291  ignore = 1;
292  } else if (pLib->audio_tap_pending) {
293  pLib->audio_tap_pending = 0;
294  ignore = 1;
295  }
296 
297  if (!ignore) {
298  return (-1); /* request failed */
299  }
300  } else {
301  if (pLib->general_b_ch_event == 1) {
302  pLib->ChannelsTraceActive = pLib->Channels;
303  pLib->general_b_ch_event = 2;
304  } else if (pLib->general_fax_event == 1) {
305  pLib->general_fax_event = 2;
306  pLib->FaxTraceActive = pLib->Channels;
307  } else if (pLib->general_mdm_event == 1) {
308  pLib->general_mdm_event = 2;
309  pLib->ModemTraceActive = pLib->Channels;
310  }
311  }
312  if (pLib->audio_trace_init == 2) {
313  pLib->audio_trace_init = 1;
314  }
315  pLib->rc_ok = 0xff; /* default OK after assign was done */
316  if ((ret = ScheduleNextTraceRequest(pLib))) {
317  return (-1);
318  }
319  } else {
320  /*
321  Process indication
322  Always 'RNR' indication if return code is pending
323  */
324  Ind = pLib->e.Ind;
325  pLib->e.Ind = 0;
326  if (pLib->removal_state) {
327  pLib->e.RNum = 0;
328  pLib->e.RNR = 2;
329  } else if (pLib->req_busy) {
330  pLib->e.RNum = 0;
331  pLib->e.RNR = 1;
332  } else {
333  if (pLib->e.complete != 0x02) {
334  /*
335  Look-ahead call, set up buffers
336  */
337  pLib->e.RNum = 1;
338  pLib->e.R->P = (byte *)&pLib->buffer[0];
339  pLib->e.R->PLength = (word)(sizeof(pLib->buffer) - 1);
340 
341  } else {
342  /*
343  Indication reception complete, process it now
344  */
345  byte *p = (byte *)&pLib->buffer[0];
346  pLib->buffer[pLib->e.R->PLength] = 0; /* terminate I.E. with zero */
347 
348  switch (Ind) {
349  case MAN_COMBI_IND: {
350  int total_length = pLib->e.R->PLength;
351  word this_ind_length;
352 
353  while (total_length > 3 && *p) {
354  Ind = *p++;
355  this_ind_length = (word)p[0] | ((word)p[1] << 8);
356  p += 2;
357 
358  switch (Ind) {
359  case MAN_INFO_IND:
360  if (process_idi_info(pLib, (diva_man_var_header_t *)p)) {
361  return (-1);
362  }
363  break;
364  case MAN_EVENT_IND:
365  if (process_idi_event(pLib, (diva_man_var_header_t *)p)) {
366  return (-1);
367  }
368  break;
369  case MAN_TRACE_IND:
370  if (pLib->trace_on == 1) {
371  /*
372  Ignore first trace event that is result of
373  EVENT_ON operation
374  */
375  pLib->trace_on++;
376  } else {
377  /*
378  Delivery XLOG buffer to application
379  */
380  if (pLib->user_proc_table.trace_proc) {
381  (*(pLib->user_proc_table.trace_proc))(pLib->user_proc_table.user_context,
382  &pLib->instance, pLib->Adapter,
383  p, this_ind_length);
384  }
385  }
386  break;
387  default:
388  diva_mnt_internal_dprintf(0, DLI_ERR, "Unknown IDI Ind (DMA mode): %02x", Ind);
389  }
390  p += (this_ind_length + 1);
391  total_length -= (4 + this_ind_length);
392  }
393  } break;
394  case MAN_INFO_IND:
395  if (process_idi_info(pLib, (diva_man_var_header_t *)p)) {
396  return (-1);
397  }
398  break;
399  case MAN_EVENT_IND:
400  if (process_idi_event(pLib, (diva_man_var_header_t *)p)) {
401  return (-1);
402  }
403  break;
404  case MAN_TRACE_IND:
405  if (pLib->trace_on == 1) {
406  /*
407  Ignore first trace event that is result of
408  EVENT_ON operation
409  */
410  pLib->trace_on++;
411  } else {
412  /*
413  Delivery XLOG buffer to application
414  */
415  if (pLib->user_proc_table.trace_proc) {
416  (*(pLib->user_proc_table.trace_proc))(pLib->user_proc_table.user_context,
417  &pLib->instance, pLib->Adapter,
418  p, pLib->e.R->PLength);
419  }
420  }
421  break;
422  default:
423  diva_mnt_internal_dprintf(0, DLI_ERR, "Unknown IDI Ind: %02x", Ind);
424  }
425  }
426  }
427  }
428 
429  if ((ret = ScheduleNextTraceRequest(pLib))) {
430  return (-1);
431  }
432 
433  return (ret);
434 }
435 
436 /*
437  Internal state machine responsible for scheduling of requests
438 */
439 static int ScheduleNextTraceRequest(diva_strace_context_t *pLib) {
440  char name[64];
441  int ret = 0;
442  int i;
443 
444  if (pLib->req_busy) {
445  return (0);
446  }
447 
448  if (pLib->removal_state == 1) {
449  if (SuperTraceREMOVE(pLib->hAdapter)) {
450  pLib->removal_state = 3;
451  } else {
452  pLib->req_busy = 1;
453  pLib->removal_state = 2;
454  }
455  return (0);
456  }
457 
458  if (pLib->removal_state) {
459  return (0);
460  }
461 
462  if (!pLib->general_b_ch_event) {
463  if ((ret = SuperTraceTraceOnRequest(pLib->hAdapter, "State\\B Event", pLib->buffer))) {
464  return (-1);
465  }
466  pLib->general_b_ch_event = 1;
467  pLib->req_busy = 1;
468  return (0);
469  }
470 
471  if (!pLib->general_fax_event) {
472  if ((ret = SuperTraceTraceOnRequest(pLib->hAdapter, "State\\FAX Event", pLib->buffer))) {
473  return (-1);
474  }
475  pLib->general_fax_event = 1;
476  pLib->req_busy = 1;
477  return (0);
478  }
479 
480  if (!pLib->general_mdm_event) {
481  if ((ret = SuperTraceTraceOnRequest(pLib->hAdapter, "State\\Modem Event", pLib->buffer))) {
482  return (-1);
483  }
484  pLib->general_mdm_event = 1;
485  pLib->req_busy = 1;
486  return (0);
487  }
488 
489  if (pLib->ChannelsTraceActive < pLib->Channels) {
490  pLib->ChannelsTraceActive++;
491  sprintf(name, "State\\B%d\\Line", pLib->ChannelsTraceActive);
492  if ((ret = SuperTraceTraceOnRequest(pLib->hAdapter, name, pLib->buffer))) {
493  pLib->ChannelsTraceActive--;
494  return (-1);
495  }
496  pLib->req_busy = 1;
497  return (0);
498  }
499 
500  if (pLib->ModemTraceActive < pLib->Channels) {
501  pLib->ModemTraceActive++;
502  sprintf(name, "State\\B%d\\Modem\\Event", pLib->ModemTraceActive);
503  if ((ret = SuperTraceTraceOnRequest(pLib->hAdapter, name, pLib->buffer))) {
504  pLib->ModemTraceActive--;
505  return (-1);
506  }
507  pLib->req_busy = 1;
508  return (0);
509  }
510 
511  if (pLib->FaxTraceActive < pLib->Channels) {
512  pLib->FaxTraceActive++;
513  sprintf(name, "State\\B%d\\FAX\\Event", pLib->FaxTraceActive);
514  if ((ret = SuperTraceTraceOnRequest(pLib->hAdapter, name, pLib->buffer))) {
515  pLib->FaxTraceActive--;
516  return (-1);
517  }
518  pLib->req_busy = 1;
519  return (0);
520  }
521 
522  if (!pLib->trace_mask_init) {
523  word tmp = 0x0000;
524  if (SuperTraceWriteVar(pLib->hAdapter,
525  pLib->buffer,
526  "Trace\\Event Enable",
527  &tmp,
528  0x87, /* MI_BITFLD */
529  sizeof(tmp))) {
530  return (-1);
531  }
532  pLib->trace_mask_init = 1;
533  pLib->req_busy = 1;
534  return (0);
535  }
536 
537  if (!pLib->audio_trace_init) {
538  dword tmp = 0x00000000;
539  if (SuperTraceWriteVar(pLib->hAdapter,
540  pLib->buffer,
541  "Trace\\AudioCh# Enable",
542  &tmp,
543  0x87, /* MI_BITFLD */
544  sizeof(tmp))) {
545  return (-1);
546  }
547  pLib->audio_trace_init = 2;
548  pLib->req_busy = 1;
549  return (0);
550  }
551 
552  if (!pLib->bchannel_init) {
553  dword tmp = 0x00000000;
554  if (SuperTraceWriteVar(pLib->hAdapter,
555  pLib->buffer,
556  "Trace\\B-Ch# Enable",
557  &tmp,
558  0x87, /* MI_BITFLD */
559  sizeof(tmp))) {
560  return (-1);
561  }
562  pLib->bchannel_init = 1;
563  pLib->req_busy = 1;
564  return (0);
565  }
566 
567  if (!pLib->trace_length_init) {
568  word tmp = 30;
569  if (SuperTraceWriteVar(pLib->hAdapter,
570  pLib->buffer,
571  "Trace\\Max Log Length",
572  &tmp,
573  0x82, /* MI_UINT */
574  sizeof(tmp))) {
575  return (-1);
576  }
577  pLib->trace_length_init = 1;
578  pLib->req_busy = 1;
579  return (0);
580  }
581 
582  if (!pLib->trace_on) {
583  if (SuperTraceTraceOnRequest(pLib->hAdapter,
584  "Trace\\Log Buffer",
585  pLib->buffer)) {
586  return (-1);
587  }
588  pLib->trace_on = 1;
589  pLib->req_busy = 1;
590  return (0);
591  }
592 
593  if (pLib->trace_event_mask != pLib->current_trace_event_mask) {
594  if (SuperTraceWriteVar(pLib->hAdapter,
595  pLib->buffer,
596  "Trace\\Event Enable",
597  &pLib->trace_event_mask,
598  0x87, /* MI_BITFLD */
599  sizeof(pLib->trace_event_mask))) {
600  return (-1);
601  }
602  pLib->current_trace_event_mask = pLib->trace_event_mask;
603  pLib->req_busy = 1;
604  return (0);
605  }
606 
607  if ((pLib->audio_tap_pending >= 0) && (pLib->audio_tap_mask != pLib->current_audio_tap_mask)) {
608  if (SuperTraceWriteVar(pLib->hAdapter,
609  pLib->buffer,
610  "Trace\\AudioCh# Enable",
611  &pLib->audio_tap_mask,
612  0x87, /* MI_BITFLD */
613  sizeof(pLib->audio_tap_mask))) {
614  return (-1);
615  }
616  pLib->current_audio_tap_mask = pLib->audio_tap_mask;
617  pLib->audio_tap_pending = 1;
618  pLib->req_busy = 1;
619  return (0);
620  }
621 
622  if ((pLib->eye_pattern_pending >= 0) && (pLib->audio_tap_mask != pLib->current_eye_pattern_mask)) {
623  if (SuperTraceWriteVar(pLib->hAdapter,
624  pLib->buffer,
625  "Trace\\EyeCh# Enable",
626  &pLib->audio_tap_mask,
627  0x87, /* MI_BITFLD */
628  sizeof(pLib->audio_tap_mask))) {
629  return (-1);
630  }
631  pLib->current_eye_pattern_mask = pLib->audio_tap_mask;
632  pLib->eye_pattern_pending = 1;
633  pLib->req_busy = 1;
634  return (0);
635  }
636 
637  if (pLib->bchannel_trace_mask != pLib->current_bchannel_trace_mask) {
638  if (SuperTraceWriteVar(pLib->hAdapter,
639  pLib->buffer,
640  "Trace\\B-Ch# Enable",
641  &pLib->bchannel_trace_mask,
642  0x87, /* MI_BITFLD */
643  sizeof(pLib->bchannel_trace_mask))) {
644  return (-1);
645  }
646  pLib->current_bchannel_trace_mask = pLib->bchannel_trace_mask;
647  pLib->req_busy = 1;
648  return (0);
649  }
650 
651  if (!pLib->trace_events_down) {
652  if (SuperTraceTraceOnRequest(pLib->hAdapter,
653  "Events Down",
654  pLib->buffer)) {
655  return (-1);
656  }
657  pLib->trace_events_down = 1;
658  pLib->req_busy = 1;
659  return (0);
660  }
661 
662  if (!pLib->l1_trace) {
663  if (SuperTraceTraceOnRequest(pLib->hAdapter,
664  "State\\Layer1",
665  pLib->buffer)) {
666  return (-1);
667  }
668  pLib->l1_trace = 1;
669  pLib->req_busy = 1;
670  return (0);
671  }
672 
673  if (!pLib->l2_trace) {
674  if (SuperTraceTraceOnRequest(pLib->hAdapter,
675  "State\\Layer2 No1",
676  pLib->buffer)) {
677  return (-1);
678  }
679  pLib->l2_trace = 1;
680  pLib->req_busy = 1;
681  return (0);
682  }
683 
684  for (i = 0; i < 30; i++) {
685  if (pLib->pending_line_status & (1L << i)) {
686  sprintf(name, "State\\B%d", i + 1);
687  if (SuperTraceReadRequest(pLib->hAdapter, name, pLib->buffer)) {
688  return (-1);
689  }
690  pLib->pending_line_status &= ~(1L << i);
691  pLib->req_busy = 1;
692  return (0);
693  }
694  if (pLib->pending_modem_status & (1L << i)) {
695  sprintf(name, "State\\B%d\\Modem", i + 1);
696  if (SuperTraceReadRequest(pLib->hAdapter, name, pLib->buffer)) {
697  return (-1);
698  }
699  pLib->pending_modem_status &= ~(1L << i);
700  pLib->req_busy = 1;
701  return (0);
702  }
703  if (pLib->pending_fax_status & (1L << i)) {
704  sprintf(name, "State\\B%d\\FAX", i + 1);
705  if (SuperTraceReadRequest(pLib->hAdapter, name, pLib->buffer)) {
706  return (-1);
707  }
708  pLib->pending_fax_status &= ~(1L << i);
709  pLib->req_busy = 1;
710  return (0);
711  }
712  if (pLib->clear_call_command & (1L << i)) {
713  sprintf(name, "State\\B%d\\Clear Call", i + 1);
714  if (SuperTraceExecuteRequest(pLib->hAdapter, name, pLib->buffer)) {
715  return (-1);
716  }
717  pLib->clear_call_command &= ~(1L << i);
718  pLib->req_busy = 1;
719  return (0);
720  }
721  }
722 
723  if (pLib->outgoing_ifc_stats) {
724  if (SuperTraceReadRequest(pLib->hAdapter,
725  "Statistics\\Outgoing Calls",
726  pLib->buffer)) {
727  return (-1);
728  }
729  pLib->outgoing_ifc_stats = 0;
730  pLib->req_busy = 1;
731  return (0);
732  }
733 
734  if (pLib->incoming_ifc_stats) {
735  if (SuperTraceReadRequest(pLib->hAdapter,
736  "Statistics\\Incoming Calls",
737  pLib->buffer)) {
738  return (-1);
739  }
740  pLib->incoming_ifc_stats = 0;
741  pLib->req_busy = 1;
742  return (0);
743  }
744 
745  if (pLib->modem_ifc_stats) {
746  if (SuperTraceReadRequest(pLib->hAdapter,
747  "Statistics\\Modem",
748  pLib->buffer)) {
749  return (-1);
750  }
751  pLib->modem_ifc_stats = 0;
752  pLib->req_busy = 1;
753  return (0);
754  }
755 
756  if (pLib->fax_ifc_stats) {
757  if (SuperTraceReadRequest(pLib->hAdapter,
758  "Statistics\\FAX",
759  pLib->buffer)) {
760  return (-1);
761  }
762  pLib->fax_ifc_stats = 0;
763  pLib->req_busy = 1;
764  return (0);
765  }
766 
767  if (pLib->b1_ifc_stats) {
768  if (SuperTraceReadRequest(pLib->hAdapter,
769  "Statistics\\B-Layer1",
770  pLib->buffer)) {
771  return (-1);
772  }
773  pLib->b1_ifc_stats = 0;
774  pLib->req_busy = 1;
775  return (0);
776  }
777 
778  if (pLib->b2_ifc_stats) {
779  if (SuperTraceReadRequest(pLib->hAdapter,
780  "Statistics\\B-Layer2",
781  pLib->buffer)) {
782  return (-1);
783  }
784  pLib->b2_ifc_stats = 0;
785  pLib->req_busy = 1;
786  return (0);
787  }
788 
789  if (pLib->d1_ifc_stats) {
790  if (SuperTraceReadRequest(pLib->hAdapter,
791  "Statistics\\D-Layer1",
792  pLib->buffer)) {
793  return (-1);
794  }
795  pLib->d1_ifc_stats = 0;
796  pLib->req_busy = 1;
797  return (0);
798  }
799 
800  if (pLib->d2_ifc_stats) {
801  if (SuperTraceReadRequest(pLib->hAdapter,
802  "Statistics\\D-Layer2",
803  pLib->buffer)) {
804  return (-1);
805  }
806  pLib->d2_ifc_stats = 0;
807  pLib->req_busy = 1;
808  return (0);
809  }
810 
811  if (!pLib->IncomingCallsCallsActive) {
812  pLib->IncomingCallsCallsActive = 1;
813  sprintf(name, "%s", "Statistics\\Incoming Calls\\Calls");
814  if ((ret = SuperTraceTraceOnRequest(pLib->hAdapter, name, pLib->buffer))) {
815  pLib->IncomingCallsCallsActive = 0;
816  return (-1);
817  }
818  pLib->req_busy = 1;
819  return (0);
820  }
821  if (!pLib->IncomingCallsConnectedActive) {
822  pLib->IncomingCallsConnectedActive = 1;
823  sprintf(name, "%s", "Statistics\\Incoming Calls\\Connected");
824  if ((ret = SuperTraceTraceOnRequest(pLib->hAdapter, name, pLib->buffer))) {
825  pLib->IncomingCallsConnectedActive = 0;
826  return (-1);
827  }
828  pLib->req_busy = 1;
829  return (0);
830  }
831  if (!pLib->OutgoingCallsCallsActive) {
832  pLib->OutgoingCallsCallsActive = 1;
833  sprintf(name, "%s", "Statistics\\Outgoing Calls\\Calls");
834  if ((ret = SuperTraceTraceOnRequest(pLib->hAdapter, name, pLib->buffer))) {
835  pLib->OutgoingCallsCallsActive = 0;
836  return (-1);
837  }
838  pLib->req_busy = 1;
839  return (0);
840  }
841  if (!pLib->OutgoingCallsConnectedActive) {
842  pLib->OutgoingCallsConnectedActive = 1;
843  sprintf(name, "%s", "Statistics\\Outgoing Calls\\Connected");
844  if ((ret = SuperTraceTraceOnRequest(pLib->hAdapter, name, pLib->buffer))) {
845  pLib->OutgoingCallsConnectedActive = 0;
846  return (-1);
847  }
848  pLib->req_busy = 1;
849  return (0);
850  }
851 
852  return (0);
853 }
854 
855 static int process_idi_event(diva_strace_context_t *pLib,
856  diva_man_var_header_t *pVar) {
857  const char *path = (char *)&pVar->path_length + 1;
858  char name[64];
859  int i;
860 
861  if (!strncmp("State\\B Event", path, pVar->path_length)) {
862  dword ch_id;
863  if (!diva_trace_read_variable(pVar, &ch_id)) {
864  if (!pLib->line_init_event && !pLib->pending_line_status) {
865  for (i = 1; i <= pLib->Channels; i++) {
866  diva_line_event(pLib, i);
867  }
868  return (0);
869  } else if (ch_id && ch_id <= pLib->Channels) {
870  return (diva_line_event(pLib, (int)ch_id));
871  }
872  return (0);
873  }
874  return (-1);
875  }
876 
877  if (!strncmp("State\\FAX Event", path, pVar->path_length)) {
878  dword ch_id;
879  if (!diva_trace_read_variable(pVar, &ch_id)) {
880  if (!pLib->pending_fax_status && !pLib->fax_init_event) {
881  for (i = 1; i <= pLib->Channels; i++) {
882  diva_fax_event(pLib, i);
883  }
884  return (0);
885  } else if (ch_id && ch_id <= pLib->Channels) {
886  return (diva_fax_event(pLib, (int)ch_id));
887  }
888  return (0);
889  }
890  return (-1);
891  }
892 
893  if (!strncmp("State\\Modem Event", path, pVar->path_length)) {
894  dword ch_id;
895  if (!diva_trace_read_variable(pVar, &ch_id)) {
896  if (!pLib->pending_modem_status && !pLib->modem_init_event) {
897  for (i = 1; i <= pLib->Channels; i++) {
898  diva_modem_event(pLib, i);
899  }
900  return (0);
901  } else if (ch_id && ch_id <= pLib->Channels) {
902  return (diva_modem_event(pLib, (int)ch_id));
903  }
904  return (0);
905  }
906  return (-1);
907  }
908 
909  /*
910  First look for Line Event
911  */
912  for (i = 1; i <= pLib->Channels; i++) {
913  sprintf(name, "State\\B%d\\Line", i);
914  if (find_var(pVar, name)) {
915  return (diva_line_event(pLib, i));
916  }
917  }
918 
919  /*
920  Look for Moden Progress Event
921  */
922  for (i = 1; i <= pLib->Channels; i++) {
923  sprintf(name, "State\\B%d\\Modem\\Event", i);
924  if (find_var(pVar, name)) {
925  return (diva_modem_event(pLib, i));
926  }
927  }
928 
929  /*
930  Look for Fax Event
931  */
932  for (i = 1; i <= pLib->Channels; i++) {
933  sprintf(name, "State\\B%d\\FAX\\Event", i);
934  if (find_var(pVar, name)) {
935  return (diva_fax_event(pLib, i));
936  }
937  }
938 
939  /*
940  Notification about loss of events
941  */
942  if (!strncmp("Events Down", path, pVar->path_length)) {
943  if (pLib->trace_events_down == 1) {
944  pLib->trace_events_down = 2;
945  } else {
946  diva_trace_error(pLib, 1, "Events Down", 0);
947  }
948  return (0);
949  }
950 
951  if (!strncmp("State\\Layer1", path, pVar->path_length)) {
952  diva_strace_read_asz(pVar, &pLib->lines[0].pInterface->Layer1[0]);
953  if (pLib->l1_trace == 1) {
954  pLib->l1_trace = 2;
955  } else {
956  diva_trace_notify_user(pLib, 0, DIVA_SUPER_TRACE_INTERFACE_CHANGE);
957  }
958  return (0);
959  }
960  if (!strncmp("State\\Layer2 No1", path, pVar->path_length)) {
961  char *tmp = &pLib->lines[0].pInterface->Layer2[0];
962  dword l2_state;
963  if (diva_strace_read_uint(pVar, &l2_state))
964  return -1;
965 
966  switch (l2_state) {
967  case 0:
968  strcpy(tmp, "Idle");
969  break;
970  case 1:
971  strcpy(tmp, "Layer2 UP");
972  break;
973  case 2:
974  strcpy(tmp, "Layer2 Disconnecting");
975  break;
976  case 3:
977  strcpy(tmp, "Layer2 Connecting");
978  break;
979  case 4:
980  strcpy(tmp, "SPID Initializing");
981  break;
982  case 5:
983  strcpy(tmp, "SPID Initialised");
984  break;
985  case 6:
986  strcpy(tmp, "Layer2 Connecting");
987  break;
988 
989  case 7:
990  strcpy(tmp, "Auto SPID Stopped");
991  break;
992 
993  case 8:
994  strcpy(tmp, "Auto SPID Idle");
995  break;
996 
997  case 9:
998  strcpy(tmp, "Auto SPID Requested");
999  break;
1000 
1001  case 10:
1002  strcpy(tmp, "Auto SPID Delivery");
1003  break;
1004 
1005  case 11:
1006  strcpy(tmp, "Auto SPID Complete");
1007  break;
1008 
1009  default:
1010  sprintf(tmp, "U:%d", (int)l2_state);
1011  }
1012  if (pLib->l2_trace == 1) {
1013  pLib->l2_trace = 2;
1014  } else {
1015  diva_trace_notify_user(pLib, 0, DIVA_SUPER_TRACE_INTERFACE_CHANGE);
1016  }
1017  return (0);
1018  }
1019 
1020  if (!strncmp("Statistics\\Incoming Calls\\Calls", path, pVar->path_length) ||
1021  !strncmp("Statistics\\Incoming Calls\\Connected", path, pVar->path_length)) {
1022  return (SuperTraceGetIncomingCallStatistics(pLib));
1023  }
1024 
1025  if (!strncmp("Statistics\\Outgoing Calls\\Calls", path, pVar->path_length) ||
1026  !strncmp("Statistics\\Outgoing Calls\\Connected", path, pVar->path_length)) {
1027  return (SuperTraceGetOutgoingCallStatistics(pLib));
1028  }
1029 
1030  return (-1);
1031 }
1032 
1033 static int diva_line_event(diva_strace_context_t *pLib, int Channel) {
1034  pLib->pending_line_status |= (1L << (Channel - 1));
1035  return (0);
1036 }
1037 
1038 static int diva_modem_event(diva_strace_context_t *pLib, int Channel) {
1039  pLib->pending_modem_status |= (1L << (Channel - 1));
1040  return (0);
1041 }
1042 
1043 static int diva_fax_event(diva_strace_context_t *pLib, int Channel) {
1044  pLib->pending_fax_status |= (1L << (Channel - 1));
1045  return (0);
1046 }
1047 
1048 /*
1049  Process INFO indications that arrive from the card
1050  Uses path of first I.E. to detect the source of the
1051  infication
1052 */
1053 static int process_idi_info(diva_strace_context_t *pLib,
1054  diva_man_var_header_t *pVar) {
1055  const char *path = (char *)&pVar->path_length + 1;
1056  char name[64];
1057  int i, len;
1058 
1059  /*
1060  First look for Modem Status Info
1061  */
1062  for (i = pLib->Channels; i > 0; i--) {
1063  len = sprintf(name, "State\\B%d\\Modem", i);
1064  if (!strncmp(name, path, len)) {
1065  return (diva_modem_info(pLib, i, pVar));
1066  }
1067  }
1068 
1069  /*
1070  Look for Fax Status Info
1071  */
1072  for (i = pLib->Channels; i > 0; i--) {
1073  len = sprintf(name, "State\\B%d\\FAX", i);
1074  if (!strncmp(name, path, len)) {
1075  return (diva_fax_info(pLib, i, pVar));
1076  }
1077  }
1078 
1079  /*
1080  Look for Line Status Info
1081  */
1082  for (i = pLib->Channels; i > 0; i--) {
1083  len = sprintf(name, "State\\B%d", i);
1084  if (!strncmp(name, path, len)) {
1085  return (diva_line_info(pLib, i, pVar));
1086  }
1087  }
1088 
1089  if (!diva_ifc_statistics(pLib, pVar)) {
1090  return (0);
1091  }
1092 
1093  return (-1);
1094 }
1095 
1096 /*
1097  MODEM INSTANCE STATE UPDATE
1098 
1099  Update Modem Status Information and issue notification to user,
1100  that will inform about change in the state of modem instance, that is
1101  associuated with this channel
1102 */
1103 static int diva_modem_info(diva_strace_context_t *pLib,
1104  int Channel,
1105  diva_man_var_header_t *pVar) {
1106  diva_man_var_header_t *cur;
1107  int i, nr = Channel - 1;
1108 
1109  for (i = pLib->modem_parse_entry_first[nr];
1110  i <= pLib->modem_parse_entry_last[nr]; i++) {
1111  if ((cur = find_var(pVar, pLib->parse_table[i].path))) {
1112  if (diva_trace_read_variable(cur, pLib->parse_table[i].variable)) {
1113  diva_trace_error(pLib, -3, __FILE__, __LINE__);
1114  return (-1);
1115  }
1116  } else {
1117  diva_trace_error(pLib, -2, __FILE__, __LINE__);
1118  return (-1);
1119  }
1120  }
1121 
1122  /*
1123  We do not use first event to notify user - this is the event that is
1124  generated as result of EVENT ON operation and is used only to initialize
1125  internal variables of application
1126  */
1127  if (pLib->modem_init_event & (1L << nr)) {
1128  diva_trace_notify_user(pLib, nr, DIVA_SUPER_TRACE_NOTIFY_MODEM_CHANGE);
1129  } else {
1130  pLib->modem_init_event |= (1L << nr);
1131  }
1132 
1133  return (0);
1134 }
1135 
1136 static int diva_fax_info(diva_strace_context_t *pLib,
1137  int Channel,
1138  diva_man_var_header_t *pVar) {
1139  diva_man_var_header_t *cur;
1140  int i, nr = Channel - 1;
1141 
1142  for (i = pLib->fax_parse_entry_first[nr];
1143  i <= pLib->fax_parse_entry_last[nr]; i++) {
1144  if ((cur = find_var(pVar, pLib->parse_table[i].path))) {
1145  if (diva_trace_read_variable(cur, pLib->parse_table[i].variable)) {
1146  diva_trace_error(pLib, -3, __FILE__, __LINE__);
1147  return (-1);
1148  }
1149  } else {
1150  diva_trace_error(pLib, -2, __FILE__, __LINE__);
1151  return (-1);
1152  }
1153  }
1154 
1155  /*
1156  We do not use first event to notify user - this is the event that is
1157  generated as result of EVENT ON operation and is used only to initialize
1158  internal variables of application
1159  */
1160  if (pLib->fax_init_event & (1L << nr)) {
1161  diva_trace_notify_user(pLib, nr, DIVA_SUPER_TRACE_NOTIFY_FAX_CHANGE);
1162  } else {
1163  pLib->fax_init_event |= (1L << nr);
1164  }
1165 
1166  return (0);
1167 }
1168 
1169 /*
1170  LINE STATE UPDATE
1171  Update Line Status Information and issue notification to user,
1172  that will inform about change in the line state.
1173 */
1174 static int diva_line_info(diva_strace_context_t *pLib,
1175  int Channel,
1176  diva_man_var_header_t *pVar) {
1177  diva_man_var_header_t *cur;
1178  int i, nr = Channel - 1;
1179 
1180  for (i = pLib->line_parse_entry_first[nr];
1181  i <= pLib->line_parse_entry_last[nr]; i++) {
1182  if ((cur = find_var(pVar, pLib->parse_table[i].path))) {
1183  if (diva_trace_read_variable(cur, pLib->parse_table[i].variable)) {
1184  diva_trace_error(pLib, -3, __FILE__, __LINE__);
1185  return (-1);
1186  }
1187  } else {
1188  diva_trace_error(pLib, -2 , __FILE__, __LINE__);
1189  return (-1);
1190  }
1191  }
1192 
1193  /*
1194  We do not use first event to notify user - this is the event that is
1195  generated as result of EVENT ON operation and is used only to initialize
1196  internal variables of application
1197 
1198  Exception is is if the line is "online". In this case we have to notify
1199  user about this confition.
1200  */
1201  if (pLib->line_init_event & (1L << nr)) {
1202  diva_trace_notify_user(pLib, nr, DIVA_SUPER_TRACE_NOTIFY_LINE_CHANGE);
1203  } else {
1204  pLib->line_init_event |= (1L << nr);
1205  if (strcmp(&pLib->lines[nr].Line[0], "Idle")) {
1206  diva_trace_notify_user(pLib, nr, DIVA_SUPER_TRACE_NOTIFY_LINE_CHANGE);
1207  }
1208  }
1209 
1210  return (0);
1211 }
1212 
1213 /*
1214  Move position to next vatianle in the chain
1215 */
1216 static diva_man_var_header_t *get_next_var(diva_man_var_header_t *pVar) {
1217  byte *msg = (byte *)pVar;
1218  byte *start;
1219  int msg_length;
1220 
1221  if (*msg != ESC) return NULL;
1222 
1223  start = msg + 2;
1224  msg_length = *(msg + 1);
1225  msg = (start + msg_length);
1226 
1227  if (*msg != ESC) return NULL;
1228 
1229  return ((diva_man_var_header_t *)msg);
1230 }
1231 
1232 /*
1233  Move position to variable with given name
1234 */
1235 static diva_man_var_header_t *find_var(diva_man_var_header_t *pVar,
1236  const char *name) {
1237  const char *path;
1238 
1239  do {
1240  path = (char *)&pVar->path_length + 1;
1241 
1242  if (!strncmp(name, path, pVar->path_length)) {
1243  break;
1244  }
1245  } while ((pVar = get_next_var(pVar)));
1246 
1247  return (pVar);
1248 }
1249 
1250 static void diva_create_line_parse_table(diva_strace_context_t *pLib,
1251  int Channel) {
1252  diva_trace_line_state_t *pLine = &pLib->lines[Channel];
1253  int nr = Channel + 1;
1254 
1255  if ((pLib->cur_parse_entry + LINE_PARSE_ENTRIES) >= pLib->parse_entries) {
1256  diva_trace_error(pLib, -1, __FILE__, __LINE__);
1257  return;
1258  }
1259 
1260  pLine->ChannelNumber = nr;
1261 
1262  pLib->line_parse_entry_first[Channel] = pLib->cur_parse_entry;
1263 
1264  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1265  "State\\B%d\\Framing", nr);
1266  pLib->parse_table[pLib->cur_parse_entry++].variable = &pLine->Framing[0];
1267 
1268  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1269  "State\\B%d\\Line", nr);
1270  pLib->parse_table[pLib->cur_parse_entry++].variable = &pLine->Line[0];
1271 
1272  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1273  "State\\B%d\\Layer2", nr);
1274  pLib->parse_table[pLib->cur_parse_entry++].variable = &pLine->Layer2[0];
1275 
1276  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1277  "State\\B%d\\Layer3", nr);
1278  pLib->parse_table[pLib->cur_parse_entry++].variable = &pLine->Layer3[0];
1279 
1280  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1281  "State\\B%d\\Remote Address", nr);
1282  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1283  &pLine->RemoteAddress[0];
1284 
1285  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1286  "State\\B%d\\Remote SubAddr", nr);
1287  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1288  &pLine->RemoteSubAddress[0];
1289 
1290  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1291  "State\\B%d\\Local Address", nr);
1292  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1293  &pLine->LocalAddress[0];
1294 
1295  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1296  "State\\B%d\\Local SubAddr", nr);
1297  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1298  &pLine->LocalSubAddress[0];
1299 
1300  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1301  "State\\B%d\\BC", nr);
1302  pLib->parse_table[pLib->cur_parse_entry++].variable = &pLine->call_BC;
1303 
1304  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1305  "State\\B%d\\HLC", nr);
1306  pLib->parse_table[pLib->cur_parse_entry++].variable = &pLine->call_HLC;
1307 
1308  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1309  "State\\B%d\\LLC", nr);
1310  pLib->parse_table[pLib->cur_parse_entry++].variable = &pLine->call_LLC;
1311 
1312  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1313  "State\\B%d\\Charges", nr);
1314  pLib->parse_table[pLib->cur_parse_entry++].variable = &pLine->Charges;
1315 
1316  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1317  "State\\B%d\\Call Reference", nr);
1318  pLib->parse_table[pLib->cur_parse_entry++].variable = &pLine->CallReference;
1319 
1320  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1321  "State\\B%d\\Last Disc Cause", nr);
1322  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1323  &pLine->LastDisconnecCause;
1324 
1325  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1326  "State\\B%d\\User ID", nr);
1327  pLib->parse_table[pLib->cur_parse_entry++].variable = &pLine->UserID[0];
1328 
1329  pLib->line_parse_entry_last[Channel] = pLib->cur_parse_entry - 1;
1330 }
1331 
1332 static void diva_create_fax_parse_table(diva_strace_context_t *pLib,
1333  int Channel) {
1334  diva_trace_fax_state_t *pFax = &pLib->lines[Channel].fax;
1335  int nr = Channel + 1;
1336 
1337  if ((pLib->cur_parse_entry + FAX_PARSE_ENTRIES) >= pLib->parse_entries) {
1338  diva_trace_error(pLib, -1, __FILE__, __LINE__);
1339  return;
1340  }
1341  pFax->ChannelNumber = nr;
1342 
1343  pLib->fax_parse_entry_first[Channel] = pLib->cur_parse_entry;
1344 
1345  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1346  "State\\B%d\\FAX\\Event", nr);
1347  pLib->parse_table[pLib->cur_parse_entry++].variable = &pFax->Event;
1348 
1349  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1350  "State\\B%d\\FAX\\Page Counter", nr);
1351  pLib->parse_table[pLib->cur_parse_entry++].variable = &pFax->Page_Counter;
1352 
1353  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1354  "State\\B%d\\FAX\\Features", nr);
1355  pLib->parse_table[pLib->cur_parse_entry++].variable = &pFax->Features;
1356 
1357  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1358  "State\\B%d\\FAX\\Station ID", nr);
1359  pLib->parse_table[pLib->cur_parse_entry++].variable = &pFax->Station_ID[0];
1360 
1361  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1362  "State\\B%d\\FAX\\Subaddress", nr);
1363  pLib->parse_table[pLib->cur_parse_entry++].variable = &pFax->Subaddress[0];
1364 
1365  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1366  "State\\B%d\\FAX\\Password", nr);
1367  pLib->parse_table[pLib->cur_parse_entry++].variable = &pFax->Password[0];
1368 
1369  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1370  "State\\B%d\\FAX\\Speed", nr);
1371  pLib->parse_table[pLib->cur_parse_entry++].variable = &pFax->Speed;
1372 
1373  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1374  "State\\B%d\\FAX\\Resolution", nr);
1375  pLib->parse_table[pLib->cur_parse_entry++].variable = &pFax->Resolution;
1376 
1377  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1378  "State\\B%d\\FAX\\Paper Width", nr);
1379  pLib->parse_table[pLib->cur_parse_entry++].variable = &pFax->Paper_Width;
1380 
1381  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1382  "State\\B%d\\FAX\\Paper Length", nr);
1383  pLib->parse_table[pLib->cur_parse_entry++].variable = &pFax->Paper_Length;
1384 
1385  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1386  "State\\B%d\\FAX\\Scanline Time", nr);
1387  pLib->parse_table[pLib->cur_parse_entry++].variable = &pFax->Scanline_Time;
1388 
1389  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1390  "State\\B%d\\FAX\\Disc Reason", nr);
1391  pLib->parse_table[pLib->cur_parse_entry++].variable = &pFax->Disc_Reason;
1392 
1393  pLib->fax_parse_entry_last[Channel] = pLib->cur_parse_entry - 1;
1394 }
1395 
1396 static void diva_create_modem_parse_table(diva_strace_context_t *pLib,
1397  int Channel) {
1398  diva_trace_modem_state_t *pModem = &pLib->lines[Channel].modem;
1399  int nr = Channel + 1;
1400 
1401  if ((pLib->cur_parse_entry + MODEM_PARSE_ENTRIES) >= pLib->parse_entries) {
1402  diva_trace_error(pLib, -1, __FILE__, __LINE__);
1403  return;
1404  }
1405  pModem->ChannelNumber = nr;
1406 
1407  pLib->modem_parse_entry_first[Channel] = pLib->cur_parse_entry;
1408 
1409  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1410  "State\\B%d\\Modem\\Event", nr);
1411  pLib->parse_table[pLib->cur_parse_entry++].variable = &pModem->Event;
1412 
1413  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1414  "State\\B%d\\Modem\\Norm", nr);
1415  pLib->parse_table[pLib->cur_parse_entry++].variable = &pModem->Norm;
1416 
1417  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1418  "State\\B%d\\Modem\\Options", nr);
1419  pLib->parse_table[pLib->cur_parse_entry++].variable = &pModem->Options;
1420 
1421  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1422  "State\\B%d\\Modem\\TX Speed", nr);
1423  pLib->parse_table[pLib->cur_parse_entry++].variable = &pModem->TxSpeed;
1424 
1425  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1426  "State\\B%d\\Modem\\RX Speed", nr);
1427  pLib->parse_table[pLib->cur_parse_entry++].variable = &pModem->RxSpeed;
1428 
1429  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1430  "State\\B%d\\Modem\\Roundtrip ms", nr);
1431  pLib->parse_table[pLib->cur_parse_entry++].variable = &pModem->RoundtripMsec;
1432 
1433  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1434  "State\\B%d\\Modem\\Symbol Rate", nr);
1435  pLib->parse_table[pLib->cur_parse_entry++].variable = &pModem->SymbolRate;
1436 
1437  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1438  "State\\B%d\\Modem\\RX Level dBm", nr);
1439  pLib->parse_table[pLib->cur_parse_entry++].variable = &pModem->RxLeveldBm;
1440 
1441  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1442  "State\\B%d\\Modem\\Echo Level dBm", nr);
1443  pLib->parse_table[pLib->cur_parse_entry++].variable = &pModem->EchoLeveldBm;
1444 
1445  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1446  "State\\B%d\\Modem\\SNR dB", nr);
1447  pLib->parse_table[pLib->cur_parse_entry++].variable = &pModem->SNRdb;
1448 
1449  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1450  "State\\B%d\\Modem\\MAE", nr);
1451  pLib->parse_table[pLib->cur_parse_entry++].variable = &pModem->MAE;
1452 
1453  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1454  "State\\B%d\\Modem\\Local Retrains", nr);
1455  pLib->parse_table[pLib->cur_parse_entry++].variable = &pModem->LocalRetrains;
1456 
1457  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1458  "State\\B%d\\Modem\\Remote Retrains", nr);
1459  pLib->parse_table[pLib->cur_parse_entry++].variable = &pModem->RemoteRetrains;
1460 
1461  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1462  "State\\B%d\\Modem\\Local Resyncs", nr);
1463  pLib->parse_table[pLib->cur_parse_entry++].variable = &pModem->LocalResyncs;
1464 
1465  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1466  "State\\B%d\\Modem\\Remote Resyncs", nr);
1467  pLib->parse_table[pLib->cur_parse_entry++].variable = &pModem->RemoteResyncs;
1468 
1469  sprintf(pLib->parse_table[pLib->cur_parse_entry].path,
1470  "State\\B%d\\Modem\\Disc Reason", nr);
1471  pLib->parse_table[pLib->cur_parse_entry++].variable = &pModem->DiscReason;
1472 
1473  pLib->modem_parse_entry_last[Channel] = pLib->cur_parse_entry - 1;
1474 }
1475 
1476 static void diva_create_parse_table(diva_strace_context_t *pLib) {
1477  int i;
1478 
1479  for (i = 0; i < pLib->Channels; i++) {
1480  diva_create_line_parse_table(pLib, i);
1481  diva_create_modem_parse_table(pLib, i);
1482  diva_create_fax_parse_table(pLib, i);
1483  }
1484 
1485  pLib->statistic_parse_first = pLib->cur_parse_entry;
1486 
1487  /*
1488  Outgoing Calls
1489  */
1490  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1491  "Statistics\\Outgoing Calls\\Calls");
1492  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1493  &pLib->InterfaceStat.outg.Calls;
1494 
1495  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1496  "Statistics\\Outgoing Calls\\Connected");
1497  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1498  &pLib->InterfaceStat.outg.Connected;
1499 
1500  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1501  "Statistics\\Outgoing Calls\\User Busy");
1502  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1503  &pLib->InterfaceStat.outg.User_Busy;
1504 
1505  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1506  "Statistics\\Outgoing Calls\\No Answer");
1507  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1508  &pLib->InterfaceStat.outg.No_Answer;
1509 
1510  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1511  "Statistics\\Outgoing Calls\\Wrong Number");
1512  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1513  &pLib->InterfaceStat.outg.Wrong_Number;
1514 
1515  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1516  "Statistics\\Outgoing Calls\\Call Rejected");
1517  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1518  &pLib->InterfaceStat.outg.Call_Rejected;
1519 
1520  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1521  "Statistics\\Outgoing Calls\\Other Failures");
1522  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1523  &pLib->InterfaceStat.outg.Other_Failures;
1524 
1525  /*
1526  Incoming Calls
1527  */
1528  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1529  "Statistics\\Incoming Calls\\Calls");
1530  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1531  &pLib->InterfaceStat.inc.Calls;
1532 
1533  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1534  "Statistics\\Incoming Calls\\Connected");
1535  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1536  &pLib->InterfaceStat.inc.Connected;
1537 
1538  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1539  "Statistics\\Incoming Calls\\User Busy");
1540  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1541  &pLib->InterfaceStat.inc.User_Busy;
1542 
1543  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1544  "Statistics\\Incoming Calls\\Call Rejected");
1545  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1546  &pLib->InterfaceStat.inc.Call_Rejected;
1547 
1548  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1549  "Statistics\\Incoming Calls\\Wrong Number");
1550  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1551  &pLib->InterfaceStat.inc.Wrong_Number;
1552 
1553  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1554  "Statistics\\Incoming Calls\\Incompatible Dst");
1555  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1556  &pLib->InterfaceStat.inc.Incompatible_Dst;
1557 
1558  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1559  "Statistics\\Incoming Calls\\Out of Order");
1560  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1561  &pLib->InterfaceStat.inc.Out_of_Order;
1562 
1563  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1564  "Statistics\\Incoming Calls\\Ignored");
1565  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1566  &pLib->InterfaceStat.inc.Ignored;
1567 
1568  /*
1569  Modem Statistics
1570  */
1571  pLib->mdm_statistic_parse_first = pLib->cur_parse_entry;
1572 
1573  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1574  "Statistics\\Modem\\Disc Normal");
1575  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1576  &pLib->InterfaceStat.mdm.Disc_Normal;
1577 
1578  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1579  "Statistics\\Modem\\Disc Unspecified");
1580  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1581  &pLib->InterfaceStat.mdm.Disc_Unspecified;
1582 
1583  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1584  "Statistics\\Modem\\Disc Busy Tone");
1585  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1586  &pLib->InterfaceStat.mdm.Disc_Busy_Tone;
1587 
1588  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1589  "Statistics\\Modem\\Disc Congestion");
1590  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1591  &pLib->InterfaceStat.mdm.Disc_Congestion;
1592 
1593  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1594  "Statistics\\Modem\\Disc Carr. Wait");
1595  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1596  &pLib->InterfaceStat.mdm.Disc_Carr_Wait;
1597 
1598  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1599  "Statistics\\Modem\\Disc Trn Timeout");
1600  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1601  &pLib->InterfaceStat.mdm.Disc_Trn_Timeout;
1602 
1603  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1604  "Statistics\\Modem\\Disc Incompat.");
1605  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1606  &pLib->InterfaceStat.mdm.Disc_Incompat;
1607 
1608  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1609  "Statistics\\Modem\\Disc Frame Rej.");
1610  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1611  &pLib->InterfaceStat.mdm.Disc_Frame_Rej;
1612 
1613  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1614  "Statistics\\Modem\\Disc V42bis");
1615  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1616  &pLib->InterfaceStat.mdm.Disc_V42bis;
1617 
1618  pLib->mdm_statistic_parse_last = pLib->cur_parse_entry - 1;
1619 
1620  /*
1621  Fax Statistics
1622  */
1623  pLib->fax_statistic_parse_first = pLib->cur_parse_entry;
1624 
1625  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1626  "Statistics\\FAX\\Disc Normal");
1627  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1628  &pLib->InterfaceStat.fax.Disc_Normal;
1629 
1630  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1631  "Statistics\\FAX\\Disc Not Ident.");
1632  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1633  &pLib->InterfaceStat.fax.Disc_Not_Ident;
1634 
1635  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1636  "Statistics\\FAX\\Disc No Response");
1637  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1638  &pLib->InterfaceStat.fax.Disc_No_Response;
1639 
1640  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1641  "Statistics\\FAX\\Disc Retries");
1642  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1643  &pLib->InterfaceStat.fax.Disc_Retries;
1644 
1645  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1646  "Statistics\\FAX\\Disc Unexp. Msg.");
1647  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1648  &pLib->InterfaceStat.fax.Disc_Unexp_Msg;
1649 
1650  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1651  "Statistics\\FAX\\Disc No Polling.");
1652  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1653  &pLib->InterfaceStat.fax.Disc_No_Polling;
1654 
1655  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1656  "Statistics\\FAX\\Disc Training");
1657  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1658  &pLib->InterfaceStat.fax.Disc_Training;
1659 
1660  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1661  "Statistics\\FAX\\Disc Unexpected");
1662  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1663  &pLib->InterfaceStat.fax.Disc_Unexpected;
1664 
1665  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1666  "Statistics\\FAX\\Disc Application");
1667  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1668  &pLib->InterfaceStat.fax.Disc_Application;
1669 
1670  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1671  "Statistics\\FAX\\Disc Incompat.");
1672  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1673  &pLib->InterfaceStat.fax.Disc_Incompat;
1674 
1675  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1676  "Statistics\\FAX\\Disc No Command");
1677  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1678  &pLib->InterfaceStat.fax.Disc_No_Command;
1679 
1680  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1681  "Statistics\\FAX\\Disc Long Msg");
1682  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1683  &pLib->InterfaceStat.fax.Disc_Long_Msg;
1684 
1685  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1686  "Statistics\\FAX\\Disc Supervisor");
1687  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1688  &pLib->InterfaceStat.fax.Disc_Supervisor;
1689 
1690  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1691  "Statistics\\FAX\\Disc SUB SEP PWD");
1692  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1693  &pLib->InterfaceStat.fax.Disc_SUB_SEP_PWD;
1694 
1695  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1696  "Statistics\\FAX\\Disc Invalid Msg");
1697  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1698  &pLib->InterfaceStat.fax.Disc_Invalid_Msg;
1699 
1700  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1701  "Statistics\\FAX\\Disc Page Coding");
1702  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1703  &pLib->InterfaceStat.fax.Disc_Page_Coding;
1704 
1705  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1706  "Statistics\\FAX\\Disc App Timeout");
1707  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1708  &pLib->InterfaceStat.fax.Disc_App_Timeout;
1709 
1710  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1711  "Statistics\\FAX\\Disc Unspecified");
1712  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1713  &pLib->InterfaceStat.fax.Disc_Unspecified;
1714 
1715  pLib->fax_statistic_parse_last = pLib->cur_parse_entry - 1;
1716 
1717  /*
1718  B-Layer1"
1719  */
1720  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1721  "Statistics\\B-Layer1\\X-Frames");
1722  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1723  &pLib->InterfaceStat.b1.X_Frames;
1724 
1725  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1726  "Statistics\\B-Layer1\\X-Bytes");
1727  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1728  &pLib->InterfaceStat.b1.X_Bytes;
1729 
1730  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1731  "Statistics\\B-Layer1\\X-Errors");
1732  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1733  &pLib->InterfaceStat.b1.X_Errors;
1734 
1735  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1736  "Statistics\\B-Layer1\\R-Frames");
1737  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1738  &pLib->InterfaceStat.b1.R_Frames;
1739 
1740  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1741  "Statistics\\B-Layer1\\R-Bytes");
1742  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1743  &pLib->InterfaceStat.b1.R_Bytes;
1744 
1745  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1746  "Statistics\\B-Layer1\\R-Errors");
1747  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1748  &pLib->InterfaceStat.b1.R_Errors;
1749 
1750  /*
1751  B-Layer2
1752  */
1753  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1754  "Statistics\\B-Layer2\\X-Frames");
1755  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1756  &pLib->InterfaceStat.b2.X_Frames;
1757 
1758  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1759  "Statistics\\B-Layer2\\X-Bytes");
1760  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1761  &pLib->InterfaceStat.b2.X_Bytes;
1762 
1763  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1764  "Statistics\\B-Layer2\\X-Errors");
1765  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1766  &pLib->InterfaceStat.b2.X_Errors;
1767 
1768  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1769  "Statistics\\B-Layer2\\R-Frames");
1770  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1771  &pLib->InterfaceStat.b2.R_Frames;
1772 
1773  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1774  "Statistics\\B-Layer2\\R-Bytes");
1775  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1776  &pLib->InterfaceStat.b2.R_Bytes;
1777 
1778  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1779  "Statistics\\B-Layer2\\R-Errors");
1780  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1781  &pLib->InterfaceStat.b2.R_Errors;
1782 
1783  /*
1784  D-Layer1
1785  */
1786  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1787  "Statistics\\D-Layer1\\X-Frames");
1788  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1789  &pLib->InterfaceStat.d1.X_Frames;
1790 
1791  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1792  "Statistics\\D-Layer1\\X-Bytes");
1793  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1794  &pLib->InterfaceStat.d1.X_Bytes;
1795 
1796  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1797  "Statistics\\D-Layer1\\X-Errors");
1798  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1799  &pLib->InterfaceStat.d1.X_Errors;
1800 
1801  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1802  "Statistics\\D-Layer1\\R-Frames");
1803  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1804  &pLib->InterfaceStat.d1.R_Frames;
1805 
1806  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1807  "Statistics\\D-Layer1\\R-Bytes");
1808  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1809  &pLib->InterfaceStat.d1.R_Bytes;
1810 
1811  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1812  "Statistics\\D-Layer1\\R-Errors");
1813  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1814  &pLib->InterfaceStat.d1.R_Errors;
1815 
1816  /*
1817  D-Layer2
1818  */
1819  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1820  "Statistics\\D-Layer2\\X-Frames");
1821  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1822  &pLib->InterfaceStat.d2.X_Frames;
1823 
1824  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1825  "Statistics\\D-Layer2\\X-Bytes");
1826  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1827  &pLib->InterfaceStat.d2.X_Bytes;
1828 
1829  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1830  "Statistics\\D-Layer2\\X-Errors");
1831  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1832  &pLib->InterfaceStat.d2.X_Errors;
1833 
1834  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1835  "Statistics\\D-Layer2\\R-Frames");
1836  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1837  &pLib->InterfaceStat.d2.R_Frames;
1838 
1839  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1840  "Statistics\\D-Layer2\\R-Bytes");
1841  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1842  &pLib->InterfaceStat.d2.R_Bytes;
1843 
1844  strcpy(pLib->parse_table[pLib->cur_parse_entry].path,
1845  "Statistics\\D-Layer2\\R-Errors");
1846  pLib->parse_table[pLib->cur_parse_entry++].variable = \
1847  &pLib->InterfaceStat.d2.R_Errors;
1848 
1849 
1850  pLib->statistic_parse_last = pLib->cur_parse_entry - 1;
1851 }
1852 
1853 static void diva_trace_error(diva_strace_context_t *pLib,
1854  int error, const char *file, int line) {
1855  if (pLib->user_proc_table.error_notify_proc) {
1856  (*(pLib->user_proc_table.error_notify_proc))(\
1857  pLib->user_proc_table.user_context,
1858  &pLib->instance, pLib->Adapter,
1859  error, file, line);
1860  }
1861 }
1862 
1863 /*
1864  Delivery notification to user
1865 */
1866 static void diva_trace_notify_user(diva_strace_context_t *pLib,
1867  int Channel,
1868  int notify_subject) {
1869  if (pLib->user_proc_table.notify_proc) {
1870  (*(pLib->user_proc_table.notify_proc))(pLib->user_proc_table.user_context,
1871  &pLib->instance,
1872  pLib->Adapter,
1873  &pLib->lines[Channel],
1874  notify_subject);
1875  }
1876 }
1877 
1878 /*
1879  Read variable value to they destination based on the variable type
1880 */
1881 static int diva_trace_read_variable(diva_man_var_header_t *pVar,
1882  void *variable) {
1883  switch (pVar->type) {
1884  case 0x03: /* MI_ASCIIZ - syting */
1885  return (diva_strace_read_asz(pVar, (char *)variable));
1886  case 0x04: /* MI_ASCII - string */
1887  return (diva_strace_read_asc(pVar, (char *)variable));
1888  case 0x05: /* MI_NUMBER - counted sequence of bytes */
1889  return (diva_strace_read_ie(pVar, (diva_trace_ie_t *)variable));
1890  case 0x81: /* MI_INT - signed integer */
1891  return (diva_strace_read_int(pVar, (int *)variable));
1892  case 0x82: /* MI_UINT - unsigned integer */
1893  return (diva_strace_read_uint(pVar, (dword *)variable));
1894  case 0x83: /* MI_HINT - unsigned integer, hex representetion */
1895  return (diva_strace_read_uint(pVar, (dword *)variable));
1896  case 0x87: /* MI_BITFLD - unsigned integer, bit representation */
1897  return (diva_strace_read_uint(pVar, (dword *)variable));
1898  }
1899 
1900  /*
1901  This type of variable is not handled, indicate error
1902  Or one problem in management interface, or in application recodeing
1903  table, or this application should handle it.
1904  */
1905  return (-1);
1906 }
1907 
1908 /*
1909  Read signed integer to destination
1910 */
1911 static int diva_strace_read_int(diva_man_var_header_t *pVar, int *var) {
1912  byte *ptr = (char *)&pVar->path_length;
1913  int value;
1914 
1915  ptr += (pVar->path_length + 1);
1916 
1917  switch (pVar->value_length) {
1918  case 1:
1919  value = *(char *)ptr;
1920  break;
1921 
1922  case 2:
1923  value = (short)GET_WORD(ptr);
1924  break;
1925 
1926  case 4:
1927  value = (int)GET_DWORD(ptr);
1928  break;
1929 
1930  default:
1931  return (-1);
1932  }
1933 
1934  *var = value;
1935 
1936  return (0);
1937 }
1938 
1939 static int diva_strace_read_uint(diva_man_var_header_t *pVar, dword *var) {
1940  byte *ptr = (char *)&pVar->path_length;
1941  dword value;
1942 
1943  ptr += (pVar->path_length + 1);
1944 
1945  switch (pVar->value_length) {
1946  case 1:
1947  value = (byte)(*ptr);
1948  break;
1949 
1950  case 2:
1951  value = (word)GET_WORD(ptr);
1952  break;
1953 
1954  case 3:
1955  value = (dword)GET_DWORD(ptr);
1956  value &= 0x00ffffff;
1957  break;
1958 
1959  case 4:
1960  value = (dword)GET_DWORD(ptr);
1961  break;
1962 
1963  default:
1964  return (-1);
1965  }
1966 
1967  *var = value;
1968 
1969  return (0);
1970 }
1971 
1972 /*
1973  Read zero terminated ASCII string
1974 */
1975 static int diva_strace_read_asz(diva_man_var_header_t *pVar, char *var) {
1976  char *ptr = (char *)&pVar->path_length;
1977  int length;
1978 
1979  ptr += (pVar->path_length + 1);
1980 
1981  if (!(length = pVar->value_length)) {
1982  length = strlen(ptr);
1983  }
1984  memcpy(var, ptr, length);
1985  var[length] = 0;
1986 
1987  return (0);
1988 }
1989 
1990 /*
1991  Read counted (with leading length byte) ASCII string
1992 */
1993 static int diva_strace_read_asc(diva_man_var_header_t *pVar, char *var) {
1994  char *ptr = (char *)&pVar->path_length;
1995 
1996  ptr += (pVar->path_length + 1);
1997  memcpy(var, ptr + 1, *ptr);
1998  var[(int)*ptr] = 0;
1999 
2000  return (0);
2001 }
2002 
2003 /*
2004  Read one information element - i.e. one string of byte values with
2005  one length byte in front
2006 */
2007 static int diva_strace_read_ie(diva_man_var_header_t *pVar,
2008  diva_trace_ie_t *var) {
2009  char *ptr = (char *)&pVar->path_length;
2010 
2011  ptr += (pVar->path_length + 1);
2012 
2013  var->length = *ptr;
2014  memcpy(&var->data[0], ptr + 1, *ptr);
2015 
2016  return (0);
2017 }
2018 
2019 static int SuperTraceSetAudioTap(void *hLib, int Channel, int on) {
2020  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
2021 
2022  if ((Channel < 1) || (Channel > pLib->Channels)) {
2023  return (-1);
2024  }
2025  Channel--;
2026 
2027  if (on) {
2028  pLib->audio_tap_mask |= (1L << Channel);
2029  } else {
2030  pLib->audio_tap_mask &= ~(1L << Channel);
2031  }
2032 
2033  /*
2034  EYE patterns have TM_M_DATA set as additional
2035  condition
2036  */
2037  if (pLib->audio_tap_mask) {
2038  pLib->trace_event_mask |= TM_M_DATA;
2039  } else {
2040  pLib->trace_event_mask &= ~TM_M_DATA;
2041  }
2042 
2043  return (ScheduleNextTraceRequest(pLib));
2044 }
2045 
2046 static int SuperTraceSetBChannel(void *hLib, int Channel, int on) {
2047  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
2048 
2049  if ((Channel < 1) || (Channel > pLib->Channels)) {
2050  return (-1);
2051  }
2052  Channel--;
2053 
2054  if (on) {
2055  pLib->bchannel_trace_mask |= (1L << Channel);
2056  } else {
2057  pLib->bchannel_trace_mask &= ~(1L << Channel);
2058  }
2059 
2060  return (ScheduleNextTraceRequest(pLib));
2061 }
2062 
2063 static int SuperTraceSetDChannel(void *hLib, int on) {
2064  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
2065 
2066  if (on) {
2067  pLib->trace_event_mask |= (TM_D_CHAN | TM_C_COMM | TM_DL_ERR | TM_LAYER1);
2068  } else {
2069  pLib->trace_event_mask &= ~(TM_D_CHAN | TM_C_COMM | TM_DL_ERR | TM_LAYER1);
2070  }
2071 
2072  return (ScheduleNextTraceRequest(pLib));
2073 }
2074 
2075 static int SuperTraceSetInfo(void *hLib, int on) {
2076  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
2077 
2078  if (on) {
2079  pLib->trace_event_mask |= TM_STRING;
2080  } else {
2081  pLib->trace_event_mask &= ~TM_STRING;
2082  }
2083 
2084  return (ScheduleNextTraceRequest(pLib));
2085 }
2086 
2087 static int SuperTraceClearCall(void *hLib, int Channel) {
2088  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
2089 
2090  if ((Channel < 1) || (Channel > pLib->Channels)) {
2091  return (-1);
2092  }
2093  Channel--;
2094 
2095  pLib->clear_call_command |= (1L << Channel);
2096 
2097  return (ScheduleNextTraceRequest(pLib));
2098 }
2099 
2100 /*
2101  Parse and update cumulative statistice
2102 */
2103 static int diva_ifc_statistics(diva_strace_context_t *pLib,
2104  diva_man_var_header_t *pVar) {
2105  diva_man_var_header_t *cur;
2106  int i, one_updated = 0, mdm_updated = 0, fax_updated = 0;
2107 
2108  for (i = pLib->statistic_parse_first; i <= pLib->statistic_parse_last; i++) {
2109  if ((cur = find_var(pVar, pLib->parse_table[i].path))) {
2110  if (diva_trace_read_variable(cur, pLib->parse_table[i].variable)) {
2111  diva_trace_error(pLib, -3 , __FILE__, __LINE__);
2112  return (-1);
2113  }
2114  one_updated = 1;
2115  if ((i >= pLib->mdm_statistic_parse_first) && (i <= pLib->mdm_statistic_parse_last)) {
2116  mdm_updated = 1;
2117  }
2118  if ((i >= pLib->fax_statistic_parse_first) && (i <= pLib->fax_statistic_parse_last)) {
2119  fax_updated = 1;
2120  }
2121  }
2122  }
2123 
2124  /*
2125  We do not use first event to notify user - this is the event that is
2126  generated as result of EVENT ON operation and is used only to initialize
2127  internal variables of application
2128  */
2129  if (mdm_updated) {
2130  diva_trace_notify_user(pLib, 0, DIVA_SUPER_TRACE_NOTIFY_MDM_STAT_CHANGE);
2131  } else if (fax_updated) {
2132  diva_trace_notify_user(pLib, 0, DIVA_SUPER_TRACE_NOTIFY_FAX_STAT_CHANGE);
2133  } else if (one_updated) {
2134  diva_trace_notify_user(pLib, 0, DIVA_SUPER_TRACE_NOTIFY_STAT_CHANGE);
2135  }
2136 
2137  return (one_updated ? 0 : -1);
2138 }
2139 
2140 static int SuperTraceGetOutgoingCallStatistics(void *hLib) {
2141  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
2142  pLib->outgoing_ifc_stats = 1;
2143  return (ScheduleNextTraceRequest(pLib));
2144 }
2145 
2146 static int SuperTraceGetIncomingCallStatistics(void *hLib) {
2147  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
2148  pLib->incoming_ifc_stats = 1;
2149  return (ScheduleNextTraceRequest(pLib));
2150 }
2151 
2152 static int SuperTraceGetModemStatistics(void *hLib) {
2153  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
2154  pLib->modem_ifc_stats = 1;
2155  return (ScheduleNextTraceRequest(pLib));
2156 }
2157 
2158 static int SuperTraceGetFaxStatistics(void *hLib) {
2159  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
2160  pLib->fax_ifc_stats = 1;
2161  return (ScheduleNextTraceRequest(pLib));
2162 }
2163 
2164 static int SuperTraceGetBLayer1Statistics(void *hLib) {
2165  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
2166  pLib->b1_ifc_stats = 1;
2167  return (ScheduleNextTraceRequest(pLib));
2168 }
2169 
2170 static int SuperTraceGetBLayer2Statistics(void *hLib) {
2171  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
2172  pLib->b2_ifc_stats = 1;
2173  return (ScheduleNextTraceRequest(pLib));
2174 }
2175 
2176 static int SuperTraceGetDLayer1Statistics(void *hLib) {
2177  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
2178  pLib->d1_ifc_stats = 1;
2179  return (ScheduleNextTraceRequest(pLib));
2180 }
2181 
2182 static int SuperTraceGetDLayer2Statistics(void *hLib) {
2183  diva_strace_context_t *pLib = (diva_strace_context_t *)hLib;
2184  pLib->d2_ifc_stats = 1;
2185  return (ScheduleNextTraceRequest(pLib));
2186 }
2187 
2188 dword DivaSTraceGetMemotyRequirement(int channels) {
2189  dword parse_entries = (MODEM_PARSE_ENTRIES + FAX_PARSE_ENTRIES + \
2190  STAT_PARSE_ENTRIES + \
2191  LINE_PARSE_ENTRIES + 1) * channels;
2192  return (sizeof(diva_strace_context_t) + \
2193  (parse_entries * sizeof(diva_strace_path2action_t)));
2194 }
Generated on Thu Jan 10 2013 13:41:26 for Linux Kernel by   doxygen 1.8.2