Line data    Source code

       1             : /* This file is part of the cmail project (http://cmail.rocks/)
       2             :  * (c) 2015 Fabian "cbdev" Stumpf
       3             :  * License: Simplified BSD (2-Clause)
       4             :  * For further information, consult LICENSE.txt
       5             :  */
       6             : 
       7          16 : int connpool_add(CONNPOOL* pool, int fd){
       8             :         unsigned i;
       9             :         int free_slot;
      10          16 :         CONNECTION new_connection = {
      11             :                 #ifndef CMAIL_NO_TLS
      12             :                 .tls_mode=TLS_NONE,
      13             :                 #endif
      14             :                 .fd = -1,
      15             :                 .aux_data = NULL
      16             :         };
      17             : 
      18          16 :         if(fd < 0 || !pool){
      19           0 :                 return -1;
      20             :         }
      21             : 
      22          16 :         new_connection.fd = fd;
      23             : 
      24             :         //initialize if needed
      25          16 :         if(!pool->conns){
      26           2 :                 pool->conns = malloc(sizeof(CONNECTION));
      27           2 :                 if(!pool->conns){
      28           0 :                         return -127;
      29             :                 }
      30             : 
      31           2 :                 pool->conns[0] = new_connection;
      32           2 :                 pool->count = 1;
      33           2 :                 return 0;
      34             :         }
      35             : 
      36             :         //check if already in set, search for free slots at same time
      37          14 :         free_slot = -1;
      38          20 :         for(i = 0; i < pool->count; i++){
      39          17 :                 if(pool->conns[i].fd == fd){
      40           0 :                         return i;
      41             :                 }
      42          17 :                 if(pool->conns[i].fd == -1){
      43          11 :                         free_slot = i;
      44          11 :                         new_connection.aux_data = pool->conns[free_slot].aux_data;
      45          11 :                         break;
      46             :                 }
      47             :         }
      48             : 
      49             :         //reallocate if needed
      50          14 :         if(free_slot < 0){
      51           3 :                 pool->conns = realloc(pool->conns, sizeof(CONNECTION) * ((pool->count) + 1));
      52           3 :                 if(!pool->conns){
      53           0 :                         return -127;
      54             :                 }
      55             : 
      56           3 :                 free_slot = pool->count++;
      57             :         }
      58             : 
      59          14 :         pool->conns[free_slot] = new_connection;
      60             : 
      61          14 :         return free_slot;
      62             : }
      63             : 
      64           0 : int connpool_remove(CONNPOOL* pool, int fd){
      65             :         unsigned i;
      66             : 
      67           0 :         if(fd < 0 || !pool || !(pool->conns)){
      68           0 :                 return -1;
      69             :         }
      70             : 
      71           0 :         for(i = 0; i < pool->count; i++){
      72           0 :                 if(pool->conns[i].fd == fd){
      73           0 :                         pool->conns[i].fd = -1;
      74           0 :                         return 0;
      75             :                 }
      76             :         }
      77             : 
      78           0 :         return 1;
      79             : }
      80             : 
      81          12 : int connpool_active(CONNPOOL pool){
      82          12 :         unsigned i, count = 0;
      83             : 
      84          23 :         for(i = 0; i < pool.count; i++){
      85          11 :                 if(pool.conns[i].fd >= 0){
      86           0 :                         count++;
      87             :                 }
      88             :         }
      89             : 
      90          12 :         return count;
      91             : }
      92             : 
      93           3 : void connpool_free(CONNPOOL* pool){
      94             :         unsigned i;
      95             : 
      96           3 :         if(!pool){
      97           3 :                 return;
      98             :         }
      99             : 
     100           3 :         if(pool->conns){
     101          12 :                 for(i = 0; i < pool->count; i++){
     102           9 :                         if(pool->conns[i].fd >= 0){
     103           8 :                                 close(pool->conns[i].fd);
     104             :                         }
     105             : 
     106           9 :                         if(pool->conns[i].aux_data){
     107           9 :                                 free(pool->conns[i].aux_data);
     108             :                         }
     109             :                 }
     110             : 
     111           3 :                 free(pool->conns);
     112           3 :                 pool->conns = NULL;
     113             :         }
     114             : 
     115           3 :         pool->count = 0;
     116             : }