source: fact/FADctrl/FADBoard.cc @ 10262

Last change on this file since 10262 was 10262, checked in by neise, 10 years ago
Added status message for each board
File size: 18.8 KB
Line 
1/********************************************************************\
2
3  Class interfacing to FAD board
4
5\********************************************************************/
6
7#include "FADBoard.h"
8using namespace std;
9
10//
11// Constructor
12//
13FADBoard::FADBoard(string Server, unsigned short ServerPort, class FAD *Parent, unsigned int Num) {
14
15  int Ret;
16
17  // Initialization
18  m = Parent;
19  Active = false;
20  Continue = true;
21  CommOK = false;
22  ACalib.Time = -1;
23  Status.Update.tv_sec = -1;
24  Port = ServerPort;
25
26  Name = new char [Server.size()+1]; // Name in permanent memory for DIM service
27  strcpy(Name, Server.c_str());
28
29  // Initialise mutex for synchronization
30  pthread_mutexattr_t Attr;
31
32  if ((Ret = pthread_mutexattr_settype(&Attr, PTHREAD_MUTEX_ERRORCHECK)) != 0) {
33    m->Message(m->ERROR, "pthread_mutex_settype() failed (%s)", strerror(Ret));
34  }
35  if ((Ret = pthread_mutex_init(&Mutex, &Attr)) != 0) {
36    m->Message(m->FATAL, "pthread_mutex_init() failed (%s)", strerror(Ret));
37  }
38
39  // Initialise condition variable for synchronization
40  if ((Ret = pthread_cond_init(&CondVar, NULL)) != 0) {
41    m->Message(m->FATAL, "pthread_cond_init() failed (%s)", strerror(Ret));
42  }
43
44  // Construct DIM service name prefix
45  stringstream ID;
46  ID << SERVER_NAME"/Board" << setfill('0') << setw(2) << Num << "/";
47
48  DIM_Name = new DimService((ID.str()+"Server").c_str(), Name);
49  DIM_Status = new DimService((ID.str()+"Status").c_str(), (char *) "");
50  DIM_ID = new DimService((ID.str()+"BoardID").c_str(), (char *) "S", NULL, 0);
51  DIM_Temp = new DimService((ID.str()+"Temperature").c_str(), (char *) "F", NULL, 0);
52  DIM_DAC = new DimService((ID.str()+"DAC").c_str(), (char *) "S", NULL, 0);
53  DIM_ROI = new DimService((ID.str()+"ROI").c_str(), (char *) "S", NULL, 0);
54
55  // Create thread that connects and receives data
56  SetStatus("Trying to connect");
57
58  if ((Ret = pthread_create(&Thread, NULL, (void * (*)(void *)) LaunchThread,(void *) this)) != 0) {
59    m->Message(m->FATAL, "pthread_create() failed in FADBoard() (%s)", strerror(Ret));
60  }
61
62  // Start thread to connect to other sockets
63  DimThread::start();
64}
65
66//
67// Destructor
68//
69FADBoard::~FADBoard() {
70
71  int Ret;
72
73  // Cancel thread (if it did not quit already) and wait for it to quit
74  if ((Ret = pthread_cancel(Thread)) != 0 && Ret != ESRCH) {
75        m->Message(m->ERROR, "pthread_cancel() failed in ~FADBoard() (%s)", strerror(Ret));
76  }
77  if ((Ret = pthread_join(Thread, NULL)) != 0) {
78        m->Message(m->ERROR, "pthread_join() failed in ~FADBoard (%s)", strerror(Ret));
79  }
80
81  delete DIM_Name;
82  delete DIM_Status;
83  delete DIM_ID;
84  delete DIM_Temp;
85  delete DIM_DAC;
86  delete DIM_ROI; 
87  delete[] Name;
88
89  // Delete condition variable
90  if ((Ret = pthread_cond_destroy(&CondVar)) != 0) {
91        m->Message(m->ERROR, "pthread_cond_destroy() failed in ~FADBoard (%s)", strerror(Ret));
92  }
93
94  // Delete mutex 
95  if ((Ret = pthread_mutex_destroy(&Mutex)) != 0) {
96        m->Message(m->ERROR, "pthread_mutex_destroy() failed in ~FADBoard (%s)", strerror(Ret));
97  }
98}
99
100
101//
102// Send data to board
103//
104void FADBoard::Send(const void *Data, size_t Bytes) {
105
106  // Do not send if not active or communication problem
107  if (!Active || !CommOK) return;
108
109  // Write data
110  ssize_t Result = write(Socket, Data, Bytes);
111
112  // Check result
113  if (Result == -1) m->PrintMessage("Error: Could not write to socket (%s)\n", strerror(errno));
114  else if ((size_t) Result < Bytes) m->PrintMessage("Error: Could only write %d bytes out of %d to socket\n", Result, Bytes);
115}
116
117void FADBoard::Send(unsigned short Data) {
118
119  unsigned short Buffer = htons(Data);
120 
121  Send(&Buffer, sizeof(unsigned short));
122}
123
124
125//
126// Get board status (mutex protected to avoid concurrent access in ReadLoop)
127//
128struct FADBoard::BoardStatus FADBoard::GetStatus() {
129
130  int Ret;
131  struct BoardStatus S;
132 
133  // Lock
134  if ((Ret = pthread_mutex_lock(&Mutex)) != 0) {
135        m->Message(m->FATAL, "pthread_mutex_lock() failed in ReadLoop() (%s)", strerror(Ret));
136  }
137
138  S = Status; 
139
140  // Unlock
141  if ((Ret = pthread_mutex_unlock(&Mutex)) != 0) {
142        m->Message(m->FATAL, "pthread_mutex_unlock() failed in Unlock() (%s)", strerror(Ret));
143  }
144 
145  return S; 
146}
147
148
149//
150// Perform amplitude calibration in steps
151//
152// The steps are intended to assure that up to date data is available
153void FADBoard::AmplitudeCalibration() {
154
155  vector<unsigned short> ROICmd;
156  unsigned short DACCmd[] = {htons(CMD_Write | (BADDR_DAC + 1)), 0, htons(CMD_Write | (BADDR_DAC + 2)), 0, htons(CMD_Write | (BADDR_DAC + 3)), 0};
157  string Message = string("ACALIBDONE")+Name;
158
159  switch (State) {
160  // ====== Part A: Check if amplitude calibration should start and initialise =====
161  case standbye:
162        if (m->Mode != m->acalib) break;
163
164        // Invalidate current calibration
165        ACalib.Time = -1;
166        Count = 0;
167
168        // Save initial board status, set all ROIs to 1024 and set DAC values
169        InitialStatus = GetStatus();
170
171        for (unsigned int i=0; i<NChips*NChannels; i++) {
172          ROICmd.push_back(htons(CMD_Write | (BADDR_ROI + i)));
173          ROICmd.push_back(htons(NBins));
174        }
175        Send(&ROICmd[0], ROICmd.size()*sizeof(unsigned short));
176
177    DACCmd[1] = htons(0);
178    DACCmd[3] = htons(0);
179    DACCmd[5] = htons(0);
180        Send(DACCmd, sizeof(DACCmd));
181
182        // Clear sum vector and set state to accumulate
183        memset(Sum, 0, sizeof(Sum));
184        State = baseline;
185        break;
186
187  // ====== Part B: Baseline calibration =====
188  case baseline:
189        // Check for stopping
190        if (m->Mode != m->acalib) {
191          State = cleanup;
192          break;
193        }
194
195        // Average
196        for (unsigned int Chip=0; Chip<NChips; Chip++) {
197          for (unsigned int Chan=0; Chan<NChannels; Chan++) {
198                for (int i=0; i<Status.ROI[Chip][Chan]; i++) {
199                  Sum[Chip][Chan][(i+Status.TriggerCell[Chip]) % NBins] += Data[Chip][Chan][i];
200                }
201          }
202        }
203    Count++;
204       
205        // Determine baseline if integration finished
206        if (Count < m->NumEventsRequested) break;
207
208        for (unsigned int i=0; i<NChips; i++) {
209          for (unsigned int j=0; j<NChannels; j++) {
210                for (unsigned int k=0; k<NBins; k++) {
211                  ACalib.Baseline[i][j][k] = Sum[i][j][k] / m->NumEventsRequested;
212                }
213          }
214        }
215
216        // Set new DAC values and start accumulation
217        DACCmd[1] = htons(50000);
218        DACCmd[3] = htons(50000);
219        DACCmd[5] = htons(50000);
220        Send(DACCmd, sizeof(DACCmd));
221
222        // Clear sum vector and set state to accumulate
223        memset(Sum, 0, sizeof(Sum));
224        Count = 0;
225        State = gain;
226        break;
227
228  // ====== Part C: Gain calibration =====
229  case gain:
230        // Check for stopping
231        if (m->Mode != m->acalib) {
232          State = cleanup;
233          break;
234        }
235
236        // Average
237        for (unsigned int Chip=0; Chip<NChips; Chip++) {
238          for (unsigned int Chan=0; Chan<NChannels; Chan++) {
239                for (int i=0; i<Status.ROI[Chip][Chan]; i++) {
240                  Sum[Chip][Chan][(i+Status.TriggerCell[Chip]) % NBins] += Data[Chip][Chan][i];
241                }
242          }
243        }
244    Count++;
245       
246        // Determine gain if integration finished
247        if (Count < m->NumEventsRequested) break;
248       
249        for (unsigned int i=0; i<NChips; i++) {
250          for (unsigned int j=0; j<NChannels; j++) {
251                for (unsigned int k=0; k<NBins; k++) {
252                  ACalib.Gain[i][j][k] = (Sum[i][j][k] / m->NumEventsRequested) - ACalib.Baseline[i][j][k];
253                }
254          }
255        }
256
257        // Set new DAC values and start accumulation
258        DACCmd[1] = htons(0);
259        DACCmd[3] = htons(0);
260        DACCmd[5] = htons(0);
261        Send(DACCmd, sizeof(DACCmd));
262
263        // Clear sum vector and set state to accumulate
264        memset(Sum, 0, sizeof(Sum));
265        Count = 0;
266        State = secondary;
267        break;
268
269  // ====== Part D: Secondary calibration =====
270  case secondary:
271        // Check for stopping
272        if (m->Mode != m->acalib) {
273          State = cleanup;
274          break;
275        }
276
277        // Average
278        for (unsigned int Chip=0; Chip<NChips; Chip++) {
279          for (unsigned int Chan=0; Chan<NChannels; Chan++) {
280                for (int i=0; i<Status.ROI[Chip][Chan]; i++) {
281                  Sum[Chip][Chan][i] = Data[Chip][Chan][i] - ACalib.Baseline[Chip][Chan][(i-Status.TriggerCell[Chip]) % NBins];
282                }
283          }
284        }
285    Count++;
286       
287        // Determine secondary baseline if integration finished
288        if (Count < m->NumEventsRequested) break;
289
290        for (unsigned int i=0; i<NChips; i++) {
291          for (unsigned int j=0; j<NChannels; j++) {
292                for (unsigned int k=0; k<NBins; k++) {
293                  ACalib.Secondary[i][j][k] = Sum[i][j][k] / (double) m->NumEventsRequested;
294                }
295          }
296        }
297
298        // Store calibration time and temperature
299        ACalib.DNA = Status.DNA;
300        ACalib.Frequency = Status.Frequency;
301        ACalib.Time = time(NULL);
302        ACalib.Temp = 0;
303        for (unsigned int i=0; i<NTemp; i++) ACalib.Temp += Status.Temp[i] / NTemp;
304
305        // Inform event thread that calibration is finished for this board
306        if (write(m->Pipe[1], Message.data(), Message.size()) == -1) {
307          m->Message(m->ERROR, "write() to Pipe[1] failed in class FADBoard::AmplitudeCalibration (%s)", strerror(errno));
308        }
309
310        State = cleanup;
311        break;
312
313  // ====== Part E: Write back original ROI and DAC settings =====
314  case cleanup:
315    // ROI values
316        ROICmd.clear();
317        for (unsigned int i=0; i<NChips*NChannels; i++) {
318          ROICmd.push_back(htons(CMD_Write | (BADDR_ROI + i)));
319          ROICmd.push_back(htons(InitialStatus.ROI[i/NChannels][i%NChannels]));
320        }
321        Send(&ROICmd[0], ROICmd.size()*sizeof(unsigned short));
322
323        // DAC values
324    DACCmd[1] = htons(InitialStatus.DAC[1]);
325    DACCmd[3] = htons(InitialStatus.DAC[2]);
326    DACCmd[5] = htons(InitialStatus.DAC[3]);
327        Send(DACCmd, sizeof(DACCmd));
328       
329        State = wait;
330        break;
331
332  // ====== Wait for Mode not being idle =====
333  case wait:
334        if (m->Mode == m->idle) State = standbye;
335        break;
336  }
337} 
338 
339//
340// Connect to board and read data
341//
342void FADBoard::ReadLoop() {
343
344  char Buffer[READ_BUFFER_SIZE];
345  unsigned int Pos = 0, Temp;
346  const PEVNT_HEADER *Header = (PEVNT_HEADER *) Buffer;
347  ssize_t Result;
348  struct sockaddr_in SocketAddress;
349  struct BoardStatus PrevStatus;
350  int Ret;
351
352  // Resolve hostname
353  struct hostent *Host = gethostbyname(Name);
354  if (Host == 0) {
355    SetStatus("Could not resolve host name '%s'", Name);
356    return;
357  }
358
359  SocketAddress.sin_family = PF_INET;
360  SocketAddress.sin_port = htons(Port);
361  SocketAddress.sin_addr = *(struct in_addr*) Host->h_addr;
362
363  // Open socket descriptor
364  if ((Socket = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
365    m->Message(m->ERROR, "Could not open socket for %s (%s)\n", Name, strerror(errno));
366    return;
367  }
368   
369  // Connect to server
370  if (connect(Socket, (struct sockaddr *) &SocketAddress, sizeof(SocketAddress)) == -1) {
371    SetStatus("Could not connect to port %hu (%s)", Port, strerror(errno));
372  }
373  else {
374        CommOK = true;
375        Active = true;
376    SetStatus("Connected");
377  }
378
379  memset(&PrevStatus, 0, sizeof(PrevStatus));
380
381  // Leave loop if program termination requested or board communication not OK
382  while (!m->ExitRequest && CommOK) {
383    // Read data from socket
384    Result = read(Socket, Buffer + Pos, sizeof(Buffer)-Pos);
385
386        // Check result of read
387        if (Result == -1) {
388          m->Message(m->ERROR, "Could not read from socket for %s, exiting read loop (%s)\n", Name, strerror(errno));
389          CommOK = false;
390          break;
391        }
392        else if (Result == 0) {
393          SetStatus("Server not existing anymore, exiting read loop");
394          CommOK = false;
395          break;
396        }
397       
398        // If not active, discard incoming data
399        if (!Active) continue;
400       
401        // Advance write pointer
402        Pos += Result;
403       
404        // Check if internal buffer full
405        if (Pos == sizeof(Buffer)) {
406          SetStatus("Internal buffer full, deleting all data in buffer");
407          Pos = 0;
408          continue;
409        }
410       
411        // Check if buffer starts with start_package_flag, remove data if not
412        Temp = 0;
413        while (ntohs(*((unsigned short *) (Buffer+Temp))) != 0xfb01 && Temp<Pos) Temp++;
414        if (Temp != 0) {
415          memmove(Buffer, Buffer+Temp, Pos-Temp);
416          Pos -= Temp;
417          SetStatus("Removed %d bytes because of start_package_flag not found", Temp);
418          continue;
419        }
420
421        // Wait until the buffer contains at least enough bytes to potentially hold a PEVNT_HEADER
422        if (Pos < sizeof(PEVNT_HEADER)) continue;
423       
424        unsigned int Length = ntohs(Header->package_length)*2*sizeof(char);
425        if (Pos < Length) continue;
426
427        // Extract data if event end package flag correct
428        if (ntohs(*(unsigned short *) (Buffer+Length-sizeof(unsigned short))) == 0x04FE) {
429
430          // Prepare pointers to channel data (channels stored in order 0,9,18,27 - 1,10,19,28 - ... - 8,17,26,35)
431          PCHANNEL *Channel[NChips*NChannels], *Pnt=(PCHANNEL *) (Header+1); 
432          for(unsigned int i=0; i<NChips*NChannels; i++) {
433                Channel[i] = Pnt;
434                Pnt = (PCHANNEL *) ((short *) (Channel[i] + 1) + ntohs(Channel[i]->roi));
435          } 
436
437          PrevStatus = Status;
438
439          // Wait until event thread processed the previous data and lock to avoid concurrent access in GetStatus()
440          Lock();
441          while (!Continue) {
442                if ((Ret = pthread_cond_wait(&CondVar, &Mutex)) != 0) {
443                  m->Message(m->ERROR, "pthread_cond_wait() failed (%s)", strerror(Ret));
444                }
445          }
446          gettimeofday(&Status.Update, NULL);
447
448          // Extract board and trigger information
449          Status.BoardID = ntohs(Header->board_id);       
450          Status.FirmwareRevision = ntohs(Header->version_no);
451          Status.BoardTime = ntohl(Header->time);
452          Status.EventCounter = ntohl(Header->fad_evt_counter);
453          Status.TriggerID = ntohl(Header->trigger_id);
454          Status.TriggerType = ntohs(Header->trigger_type);
455          Status.TriggerCRC = ntohs(Header->trigger_crc);
456          Status.DNA = Header->DNA;
457
458          // Extract frequency related information
459          Status.Frequency = ntohl(Header->REFCLK_frequency)/1.0e3*2.048;
460          Status.PhaseShift = Header->adc_clock_phase_shift;
461          for (unsigned int i=0; i<NChips; i++) {
462                if ((ntohs(Header->PLLLCK)>>12 & (1<<i)) != 0) Status.Lock[i] = true;
463                else Status.Lock[i] = false;
464          }
465
466          // Extract Firmware status info
467          Status.denable = (bool) ( ntohs(Header->PLLLCK) & (1<<11) );
468          Status.dwrite = (bool) ( ntohs(Header->PLLLCK) & (1<<10) );
469          Status.DCM_lock = (bool) ( ntohs(Header->PLLLCK) & (1<<9) );
470          Status.DCM_ready = (bool) ( ntohs(Header->PLLLCK) & (1<<8) );
471          Status.spi_clk = (bool) ( ntohs(Header->PLLLCK) & (1<<7) );
472
473          // Extract temperatures (MSB indicates if temperature is positive or negative)
474          for (unsigned int i=0; i<NTemp; i++) {
475                if ((ntohs(Header->drs_temperature[i]) & 0x8000) == 0) Status.Temp[i] = float(ntohs(Header->drs_temperature[i]) >> 3)/16;
476                else Status.Temp[i] = float(0xE000 | (ntohs(Header->drs_temperature[i])) >> 3)/16;
477          }
478
479          // Extract DAC channels
480          for (unsigned int i=0; i<NDAC; i++) Status.DAC[i] = ntohs(Header->dac[i]);
481
482          short Buf;
483          for (unsigned int Chip=0; Chip<NChips; Chip++) {
484                // Extract trigger cells         
485                Status.TriggerCell[Chip] = (int) ntohs(Channel[Chip]->start_cell);
486         
487                for (unsigned int Chan=0; Chan<NChannels; Chan++) {
488                  // Extract ROI
489                  Status.ROI[Chip][Chan] = ntohs(Channel[Chip+NChips*Chan]->roi);
490
491                  // Extract ADC data (stored in 12 bit signed twis complement with out-of-range-bit and leading zeroes)
492                  for (int i=0; i<Status.ROI[Chip][Chan]; i++) {
493                          Buf = ntohs(Channel[Chip+NChips*Chan]->adc_data[i]);
494                          (Buf <<= 4) >>= 4;                    //delete the sign-bit by shifting left and shift back
495                          Data[Chip][Chan][i] = Buf;                                   
496                  }
497                }
498          }
499         
500          // Prepare predicate for condition variable
501          Continue = false;
502          Unlock();
503         
504          // Amplitude calibration (will check if Mode is acalib)
505          AmplitudeCalibration();
506
507          // Update DIM services if necessary
508          if (memcmp(PrevStatus.Temp, Status.Temp, sizeof(Status.Temp)) != 0) {
509                DIM_Temp->updateService(Status.Temp, sizeof(Status.Temp));
510          }
511          if (memcmp(PrevStatus.DAC, Status.DAC, sizeof(Status.DAC)) != 0) {
512                DIM_DAC->updateService(Status.DAC, sizeof(Status.DAC));
513          } 
514          if (memcmp(PrevStatus.ROI, Status.ROI, sizeof(Status.ROI)) != 0) {
515                DIM_ROI->updateService(Status.ROI, sizeof(Status.ROI));
516          } 
517          if (PrevStatus.BoardID != Status.BoardID) {
518                DIM_ID->updateService(&Status.BoardID, sizeof(Status.BoardID));
519          }
520         
521          // Inform event thread of new data
522          string Message = string("EVENT")+Name;
523          if (write(m->Pipe[1], Message.data(), Message.size()) == -1) {
524                m->Message(m->ERROR, "write() to Pipe[1] failed in class FADBoard (%s)", strerror(errno));
525                m->ExitRequest = true;
526          }         
527        }
528        else SetStatus("End package flag incorrect, removing corrupt event");
529
530        // Remove event data from internal buffer
531        memmove(Buffer, Buffer+Length, Pos-Length);
532        Pos = Pos-Length;       
533  } // while()
534 
535  // Set inactive and close socket descriptor
536  Active = false;
537
538  if (close(Socket) == -1) {
539        m->Message(m->ERROR, "Could not close socket descriptor for board %s (%s)", Name, strerror(errno)); 
540  }
541
542}
543
544//
545// Launch read thread inside class
546//
547void FADBoard::LaunchThread(class FADBoard *m) {
548
549  m->ReadLoop();
550}
551
552
553//
554// Set status message
555//
556void FADBoard::SetStatus(const char *Format, ...) {
557
558  int Ret;
559
560  // Assemble message
561  va_list ArgumentPointer;
562  va_start(ArgumentPointer, Format);
563  Lock();
564  Ret = vsnprintf(Status.Message, sizeof(Status.Message), Format, ArgumentPointer);
565  Unlock();
566  va_end(ArgumentPointer);
567
568  if (Ret == -1) m->Message(m->FATAL, "snprintf() in FADBoard::SetStatus() failed (%s)", strerror(errno));
569
570  // Update status service
571  DIM_Status->updateService(Status.Message);
572}
573
574
575//
576// Lock and unlock mutex
577//
578void FADBoard::Lock() {
579
580  int Ret;
581
582  if ((Ret = pthread_mutex_lock(&Mutex)) != 0) {
583        m->Message(m->FATAL, "pthread_mutex_lock() failed in class FADBoard (%s)", strerror(Ret));
584  }
585}
586
587void FADBoard::Unlock() {
588
589  int Ret;
590
591  if ((Ret = pthread_mutex_unlock(&Mutex)) != 0) {
592        m->Message(m->FATAL, "pthread_mutex_unlock() failed in class FADBoard (%s)", strerror(Ret));
593  }
594}
595
596
597//
598// Open other sockets
599//
600//  Error reporting is limited as this function is expected to be removed when firmware allows single socket
601//
602void FADBoard::threadHandler() {
603
604  int List[] = {5001, 5002, 5003, 5004, 5005, 5006, 5007};
605  int Socket[sizeof(List)/sizeof(int)], MaxSocketNum, Ret;
606  fd_set DescriptorList;
607  char Buffer[1000000];
608 
609  // Resolve hostname
610  struct hostent *Host = gethostbyname(Name);
611  if (Host == 0) return;
612
613  // Connect to server
614  struct sockaddr_in SocketAddress;
615  SocketAddress.sin_family = PF_INET;
616  SocketAddress.sin_addr = *(struct in_addr*) Host->h_addr;
617
618  for (unsigned int i=0; i<sizeof(List)/sizeof(int); i++) {
619        // Open socket descriptor
620        if ((Socket[i] = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
621      m->Message(m->ERROR, "OtherSockets: Could not open socket for port %d (%s)\n", List[i], strerror(errno));
622      return;
623        }
624        MaxSocketNum = *max_element(Socket, Socket+sizeof(List)/sizeof(int));
625         
626        // Connect to server
627    SocketAddress.sin_port = htons((unsigned short) List[i]);
628        if (connect(Socket[i], (struct sockaddr *) &SocketAddress, sizeof(SocketAddress)) == -1) return;
629  }
630 
631  while(true) {
632    // Wait for data from sockets
633    FD_ZERO(&DescriptorList);   
634    for (unsigned int i=0; i<sizeof(List)/sizeof(int); i++) FD_SET(Socket[i], &DescriptorList);
635    if (select(MaxSocketNum+1, &DescriptorList, NULL, NULL, NULL) == -1) {
636      m->Message(m->ERROR, "OtherSockets: Error with select() (%s)\n", strerror(errno));
637      break;
638    }
639       
640        // Data from socket
641        for (unsigned int i=0; i<sizeof(List)/sizeof(int); i++) if (FD_ISSET(Socket[i], &DescriptorList)) {
642          Ret = read(Socket[i], Buffer, sizeof(Buffer));
643      if (Ret == -1) m->Message(m->ERROR, "OtherSockets: Error reading from port %d (%s)\n", List[i], strerror(errno));
644    }
645  }
646
647  // Close all sockets
648  for (unsigned int i=0; i<sizeof(List)/sizeof(int); i++) {
649        if ((Socket[i] != -1) && (close(Socket[i]) == -1)) {
650          m->Message(m->ERROR, "OtherSockets: Could not close socket of port %d (%s)", List[i], strerror(errno)); 
651        }
652  }
653}
Note: See TracBrowser for help on using the repository browser.