/[svn]/liblscp/trunk/src/common.c
ViewVC logotype

Diff of /liblscp/trunk/src/common.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 158 by capela, Tue Jun 29 16:39:11 2004 UTC revision 378 by capela, Sun Feb 13 17:20:46 2005 UTC
# Line 49  void lscp_client_set_result ( lscp_clien Line 49  void lscp_client_set_result ( lscp_clien
49          pClient->pszResult = strdup(lscp_ltrim(pszResult));          pClient->pszResult = strdup(lscp_ltrim(pszResult));
50  }  }
51    
52  // The main client requester call executive.  
53  lscp_status_t lscp_client_call ( lscp_client_t *pClient, const char *pszQuery )  // The common client receiver executive.
54    lscp_status_t lscp_client_recv ( lscp_client_t *pClient, char *pchBuffer, int *pcchBuffer, int iTimeout )
55  {  {
56      fd_set fds;                         // File descriptor list for select().      fd_set fds;                         // File descriptor list for select().
57      int    fd, fdmax;                   // Maximum file descriptor number.      int    fd, fdmax;                   // Maximum file descriptor number.
58      struct timeval tv;                  // For specifying a timeout value.      struct timeval tv;                  // For specifying a timeout value.
59      int    iSelect;                     // Holds select return status.      int    iSelect;                     // Holds select return status.
60      int    iTimeout;  
61        lscp_status_t ret = LSCP_FAILED;
62    
63        if (pClient == NULL)
64            return ret;
65    
66        // Prepare for waiting on select...
67        fd = (int) pClient->cmd.sock;
68        FD_ZERO(&fds);
69        FD_SET((unsigned int) fd, &fds);
70        fdmax = fd;
71    
72        // Use the timeout select feature...
73        if (iTimeout < 1)
74            iTimeout = pClient->iTimeout;
75        if (iTimeout > 1000) {
76            tv.tv_sec = iTimeout / 1000;
77            iTimeout -= tv.tv_sec * 1000;
78        }
79        else tv.tv_sec = 0;
80        tv.tv_usec = iTimeout * 1000;
81    
82        // Wait for event...
83        iSelect = select(fdmax + 1, &fds, NULL, NULL, &tv);
84        if (iSelect > 0 && FD_ISSET(fd, &fds)) {
85            // May recv now...
86            *pcchBuffer = recv(pClient->cmd.sock, pchBuffer, *pcchBuffer, 0);
87            if (*pcchBuffer > 0)
88                ret = LSCP_OK;
89            else if (*pcchBuffer < 0)
90                lscp_socket_perror("lscp_client_recv: recv");
91            else if (*pcchBuffer == 0) {
92                // Damn, server probably disconnected,
93                // we better free everything down here.
94                lscp_socket_agent_free(&(pClient->evt));
95                lscp_socket_agent_free(&(pClient->cmd));
96                // Fake a result message.
97                ret = LSCP_QUIT;
98            }
99        }   // Check if select has timed out.
100        else if (iSelect == 0)
101            ret = LSCP_TIMEOUT;
102        else
103            lscp_socket_perror("lscp_client_recv: select");
104    
105        return ret;
106    }
107    
108    
109    // The main client requester call executive.
110    lscp_status_t lscp_client_call ( lscp_client_t *pClient, const char *pszQuery )
111    {
112      int    cchQuery;      int    cchQuery;
113      char   achResult[LSCP_BUFSIZ];      char   achResult[LSCP_BUFSIZ];
114      int    cchResult;      int    cchResult;
# Line 84  lscp_status_t lscp_client_call ( lscp_cl Line 136  lscp_status_t lscp_client_call ( lscp_cl
136      // Send data, and then, wait for the result...      // Send data, and then, wait for the result...
137      cchQuery = strlen(pszQuery);      cchQuery = strlen(pszQuery);
138      if (send(pClient->cmd.sock, pszQuery, cchQuery, 0) < cchQuery) {      if (send(pClient->cmd.sock, pszQuery, cchQuery, 0) < cchQuery) {
139          lscp_socket_perror("_lscp_client_call: send");          lscp_socket_perror("lscp_client_call: send");
140          pszResult = "Failure during send operation";          pszResult = "Failure during send operation";
141          lscp_client_set_result(pClient, pszResult, iErrno);          lscp_client_set_result(pClient, pszResult, iErrno);
142          return ret;          return ret;
143      }      }
144    
145      // Prepare for waiting on select...      // Wait for receive event...
146      fd = (int) pClient->cmd.sock;      cchResult = sizeof(achResult);
147      FD_ZERO(&fds);      ret = lscp_client_recv(pClient, achResult, &cchResult, pClient->iTimeout);
148      FD_SET((unsigned int) fd, &fds);  
149      fdmax = fd;      switch (ret) {
150    
151      // Use the timeout select feature...        case LSCP_OK:
152      iTimeout = pClient->iTimeout;          // Always force the result to be null terminated (and trim trailing CRLFs)!
153      if (iTimeout > 1000) {          while (cchResult > 0 && (achResult[cchResult - 1] == '\n' || achResult[cchResult- 1] == '\r'))
154          tv.tv_sec = iTimeout / 1000;              cchResult--;
155          iTimeout -= tv.tv_sec * 1000;          achResult[cchResult] = (char) 0;
156      }          // Check if the response it's an error or warning message.
157      else tv.tv_sec = 0;          if (strncasecmp(achResult, "WRN:", 4) == 0)
158      tv.tv_usec = iTimeout * 1000;              ret = LSCP_WARNING;
159            else if (strncasecmp(achResult, "ERR:", 4) == 0)
160      // Wait for event...              ret = LSCP_ERROR;
161      iSelect = select(fdmax + 1, &fds, NULL, NULL, &tv);          // So we got a result...
162      if (iSelect > 0 && FD_ISSET(fd, &fds)) {          if (ret == LSCP_OK) {
163          // May recv now...              // Reset errno in case of success.
164          cchResult = recv(pClient->cmd.sock, achResult, sizeof(achResult), 0);              iErrno = 0;
165          if (cchResult > 0) {              // Is it a special successful response?
166              // Assume early success.              if (strncasecmp(achResult, "OK[", 3) == 0) {
167              ret = LSCP_OK;                  // Parse the OK message, get the return string under brackets...
             // Always force the result to be null terminated (and trim trailing CRLFs)!  
             while (cchResult > 0 && (achResult[cchResult - 1] == '\n' || achResult[cchResult- 1] == '\r'))  
                 cchResult--;  
             achResult[cchResult] = (char) 0;  
             // Check if the response it's an error or warning message.  
             if (strncasecmp(achResult, "WRN:", 4) == 0)  
                 ret = LSCP_WARNING;  
             else if (strncasecmp(achResult, "ERR:", 4) == 0)  
                 ret = LSCP_ERROR;  
             // So we got a result...  
             if (ret == LSCP_OK) {  
                 // Reset errno in case of success.  
                 iErrno = 0;  
                 // Is it a special successful response?  
                 if (strncasecmp(achResult, "OK[", 3) == 0) {  
                     // Parse the OK message, get the return string under brackets...  
                     pszToken = lscp_strtok(achResult, pszSeps, &(pch));  
                     if (pszToken)  
                         pszResult = lscp_strtok(NULL, pszSeps, &(pch));  
                 }  
                 else pszResult = achResult;  
                 // The result string is now set to the command response, if any.  
             } else {  
                 // Parse the error/warning message, skip first colon...  
168                  pszToken = lscp_strtok(achResult, pszSeps, &(pch));                  pszToken = lscp_strtok(achResult, pszSeps, &(pch));
169                    if (pszToken)
170                        pszResult = lscp_strtok(NULL, pszSeps, &(pch));
171                }
172                else pszResult = achResult;
173                // The result string is now set to the command response, if any.
174            } else {
175                // Parse the error/warning message, skip first colon...
176                pszToken = lscp_strtok(achResult, pszSeps, &(pch));
177                if (pszToken) {
178                    // Get the error number...
179                    pszToken = lscp_strtok(NULL, pszSeps, &(pch));
180                  if (pszToken) {                  if (pszToken) {
181                      // Get the error number...                      iErrno = atoi(pszToken);
182                      pszToken = lscp_strtok(NULL, pszSeps, &(pch));                      // And make the message text our final result.
183                      if (pszToken) {                      pszResult = lscp_strtok(NULL, pszSeps, &(pch));
                         iErrno = atoi(pszToken);  
                         // And make the message text our final result.  
                         pszResult = lscp_strtok(NULL, pszSeps, &(pch));  
                     }  
184                  }                  }
                 // The result string is set to the error/warning message text.  
185              }              }
186                // The result string is set to the error/warning message text.
187          }          }
188          else if (cchResult == 0) {          break;
189              // Damn, server disconnected, we better free everything down here.  
190              lscp_socket_agent_free(&(pClient->evt));        case LSCP_TIMEOUT:
             lscp_socket_agent_free(&(pClient->cmd));  
             // Fake a result message.  
             ret = LSCP_QUIT;  
             pszResult = "Server terminated the connection";  
             iErrno = (int) ret;  
         } else {  
             // What's down?  
             lscp_socket_perror("_lscp_client_call: recv");  
             pszResult = "Failure during receive operation";  
         }  
     }   // Check if select has timed out.  
     else if (iSelect == 0) {  
191          // Fake a result message.          // Fake a result message.
         ret = LSCP_TIMEOUT;  
192          pszResult = "Timeout during receive operation";          pszResult = "Timeout during receive operation";
193          iErrno = (int) ret;          iErrno = (int) ret;
194     }          break;
195      else lscp_socket_perror("_lscp_client_call: select");  
196          case LSCP_QUIT:
197            // Fake a result message.
198            pszResult = "Server terminated the connection";
199            iErrno = (int) ret;
200            break;
201    
202          case LSCP_FAILED:
203          default:
204            // What's down?
205            pszResult = "Failure during receive operation";
206            break;
207        }
208    
209      // Make the result official...      // Make the result official...
210      lscp_client_set_result(pClient, pszResult, iErrno);      lscp_client_set_result(pClient, pszResult, iErrno);
# Line 223  char *lscp_unquote ( char **ppsz, int du Line 257  char *lscp_unquote ( char **ppsz, int du
257      return psz;      return psz;
258  }  }
259    
260    // Unquote and make a duplicate of an in-split string.
261    void lscp_unquote_dup ( char **ppszDst, char **ppszSrc )
262    {
263         // Free desteny string, if already there.
264         if (*ppszDst)
265             free(*ppszDst);
266         *ppszDst = NULL;
267         // Unquote and duplicate.
268         if (*ppszSrc)
269             *ppszDst = lscp_unquote(ppszSrc, 1);
270    }
271    
272    
273  // Custom tokenizer.  // Custom tokenizer.
274  char *lscp_strtok ( char *pchBuffer, const char *pszSeps, char **ppch )  char *lscp_strtok ( char *pchBuffer, const char *pszSeps, char **ppch )
# Line 346  int *lscp_isplit_create ( const char *ps Line 392  int *lscp_isplit_create ( const char *ps
392      int iSize, i, j, cchSeps;      int iSize, i, j, cchSeps;
393      int *piSplit, *piNewSplit;      int *piSplit, *piNewSplit;
394    
395        // Get it clean first.
396        pchHead = lscp_ltrim((char *) pszCsv);
397        if (*pchHead == (char) 0)
398            return NULL;
399        
400      // Initial size is one chunk away.      // Initial size is one chunk away.
401      iSize = LSCP_SPLIT_CHUNK1;      iSize = LSCP_SPLIT_CHUNK1;
402      // Allocate and split...      // Allocate and split...
# Line 355  int *lscp_isplit_create ( const char *ps Line 406  int *lscp_isplit_create ( const char *ps
406    
407      // Make a copy of the original string.      // Make a copy of the original string.
408      i = 0;      i = 0;
     pchHead = (char *) pszCsv;  
409      if ((piSplit[i++] = atoi(pchHead)) < 0) {      if ((piSplit[i++] = atoi(pchHead)) < 0) {
410          free(piSplit);          free(piSplit);
411          return NULL;          return NULL;
# Line 445  lscp_param_t *lscp_psplit_create ( const Line 495  lscp_param_t *lscp_psplit_create ( const
495          ppSplit[i].key = pszHead;          ppSplit[i].key = pszHead;
496          pszHead = pch + cchSeps1;          pszHead = pch + cchSeps1;
497          *pch = (char) 0;          *pch = (char) 0;
498          ppSplit[i].value.psz = lscp_unquote(&pszHead, 0);          ppSplit[i].value = lscp_unquote(&pszHead, 0);
499          if ((pch = strpbrk(pszHead, pszSeps2)) != NULL) {          if ((pch = strpbrk(pszHead, pszSeps2)) != NULL) {
500              pszHead = pch + cchSeps2;              pszHead = pch + cchSeps2;
501              *pch = (char) 0;              *pch = (char) 0;
# Line 455  lscp_param_t *lscp_psplit_create ( const Line 505  lscp_param_t *lscp_psplit_create ( const
505              ppNewSplit = (lscp_param_t *) malloc(iSize * sizeof(lscp_param_t));              ppNewSplit = (lscp_param_t *) malloc(iSize * sizeof(lscp_param_t));
506              if (ppNewSplit) {              if (ppNewSplit) {
507                  for (j = 0; j < i; j++) {                  for (j = 0; j < i; j++) {
508                      ppNewSplit[j].key = ppSplit[j].key;                      ppNewSplit[j].key   = ppSplit[j].key;
509                      ppNewSplit[j].value.psz = ppSplit[j].value.psz;                      ppNewSplit[j].value = ppSplit[j].value;
510                  }                  }
511                  free(ppSplit);                  free(ppSplit);
512                  ppSplit = ppNewSplit;                  ppSplit = ppNewSplit;
# Line 468  lscp_param_t *lscp_psplit_create ( const Line 518  lscp_param_t *lscp_psplit_create ( const
518          free(pszHead);          free(pszHead);
519    
520      for ( ; i < iSize; i++) {      for ( ; i < iSize; i++) {
521          ppSplit[i].key = NULL;          ppSplit[i].key   = NULL;
522          ppSplit[i].value.psz = NULL;          ppSplit[i].value = NULL;
523      }      }
524    
525      return ppSplit;      return ppSplit;
# Line 506  int lscp_psplit_size ( lscp_param_t *ppS Line 556  int lscp_psplit_size ( lscp_param_t *ppS
556  #endif // LSCP_PSPLIT_COUNT  #endif // LSCP_PSPLIT_COUNT
557    
558    
559    // Allocate a parameter list, optionally copying an existing one.
560    void lscp_plist_alloc (lscp_param_t **ppList)
561    {
562        lscp_param_t *pParams;
563        int iSize, i;
564    
565        if (ppList) {
566            iSize = LSCP_SPLIT_CHUNK1;
567            pParams = (lscp_param_t *) malloc(iSize * sizeof(lscp_param_t));
568            if (pParams) {
569                for (i = 0 ; i < iSize; i++) {
570                    pParams[i].key   = NULL;
571                    pParams[i].value = NULL;
572                }
573            }
574            *ppList = pParams;
575        }
576    }
577    
578    
579    // Destroy a parameter list, including all it's contents.
580    void lscp_plist_free ( lscp_param_t **ppList )
581    {
582        lscp_param_t *pParams;
583        int i;
584        
585        if (ppList) {
586            if (*ppList) {
587                pParams = *ppList;
588                for (i = 0; pParams && pParams[i].key; i++) {
589                    free(pParams[i].key);
590                    free(pParams[i].value);
591                }
592                free(pParams);
593            }
594            *ppList = NULL;
595        }
596    }
597    
598    
599    // Add an item to a parameter list, growing it as fit.
600    void lscp_plist_append ( lscp_param_t **ppList, const char *pszKey, const char *pszValue )
601    {
602        lscp_param_t *pParams;
603        lscp_param_t *pNewParams;
604        int iSize, iNewSize;
605        int i = 0;
606        
607        if (ppList && *ppList) {
608            pParams = *ppList;
609            while (pParams[i].key) {
610                if (strcasecmp(pParams[i].key, pszKey) == 0) {
611                    if (pParams[i].value)
612                        free(pParams[i].value);
613                    pParams[i].value = strdup(pszValue);
614                    return;
615                }
616                i++;
617            }
618            iSize = LSCP_SPLIT_SIZE(i);
619            pParams[i].key   = strdup(pszKey);
620            pParams[i].value = strdup(pszValue);
621            if (++i >= iSize) {
622                iNewSize   = iSize + LSCP_SPLIT_CHUNK1;
623                pNewParams = (lscp_param_t *) malloc(iNewSize * sizeof(lscp_param_t));
624                for (i = 0; i < iSize; i++) {
625                    pParams[i].key   = pParams[i].key;
626                    pParams[i].value = pParams[i].value;
627                }
628                for ( ; i < iNewSize; i++) {
629                    pNewParams[i].key   = NULL;
630                    pNewParams[i].value = NULL;
631                }
632                free(pParams);
633                *ppList = pNewParams;
634            }
635        }
636    }
637    
638    #ifdef LSCP_PLIST_COUNT
639    
640    // Compute a parameter list valid item count.
641    int lscp_plist_count ( lscp_param_t **ppList )
642    {
643        lscp_param_t *pParams;
644        int i = 0;
645        if (ppList && *ppList) {
646            pParams = *ppList;
647            while (pParams[i].key)
648                i++;
649        }
650        return i;
651    }
652    
653    // Compute the legal parameter list size.
654    int lscp_plist_size ( lscp_param_t **ppList )
655    {
656        return LSCP_SPLIT_SIZE(lscp_plist_count(ppList));
657    }
658    
659    #endif // LSCP_PLIST_COUNT
660    
661    
662  //-------------------------------------------------------------------------  //-------------------------------------------------------------------------
663  // Engine info struct helper functions.  // Engine info struct helper functions.
664    
# Line 515  void lscp_engine_info_init ( lscp_engine Line 668  void lscp_engine_info_init ( lscp_engine
668      pEngineInfo->version     = NULL;      pEngineInfo->version     = NULL;
669  }  }
670    
671  void lscp_engine_info_reset ( lscp_engine_info_t *pEngineInfo )  void lscp_engine_info_free ( lscp_engine_info_t *pEngineInfo )
672  {  {
673      if (pEngineInfo->description)      if (pEngineInfo->description)
674          free(pEngineInfo->description);          free(pEngineInfo->description);
675      if (pEngineInfo->version)      if (pEngineInfo->version)
676          free(pEngineInfo->version);          free(pEngineInfo->version);
677    }
678    
679    void lscp_engine_info_reset ( lscp_engine_info_t *pEngineInfo )
680    {
681        lscp_engine_info_free(pEngineInfo);
682      lscp_engine_info_init(pEngineInfo);      lscp_engine_info_init(pEngineInfo);
683  }  }
684    
# Line 537  void lscp_channel_info_init ( lscp_chann Line 694  void lscp_channel_info_init ( lscp_chann
694      pChannelInfo->audio_routing     = NULL;      pChannelInfo->audio_routing     = NULL;
695      pChannelInfo->instrument_file   = NULL;      pChannelInfo->instrument_file   = NULL;
696      pChannelInfo->instrument_nr     = 0;      pChannelInfo->instrument_nr     = 0;
697        pChannelInfo->instrument_name   = NULL;
698      pChannelInfo->instrument_status = 0;      pChannelInfo->instrument_status = 0;
699      pChannelInfo->midi_device       = 0;      pChannelInfo->midi_device       = 0;
700      pChannelInfo->midi_port         = 0;      pChannelInfo->midi_port         = 0;
# Line 544  void lscp_channel_info_init ( lscp_chann Line 702  void lscp_channel_info_init ( lscp_chann
702      pChannelInfo->volume            = 0.0;      pChannelInfo->volume            = 0.0;
703  }  }
704    
705  void lscp_channel_info_reset ( lscp_channel_info_t *pChannelInfo )  void lscp_channel_info_free ( lscp_channel_info_t *pChannelInfo )
706  {  {
707      if (pChannelInfo->engine_name)      if (pChannelInfo->engine_name)
708          free(pChannelInfo->engine_name);          free(pChannelInfo->engine_name);
# Line 552  void lscp_channel_info_reset ( lscp_chan Line 710  void lscp_channel_info_reset ( lscp_chan
710          lscp_szsplit_destroy(pChannelInfo->audio_routing);          lscp_szsplit_destroy(pChannelInfo->audio_routing);
711      if (pChannelInfo->instrument_file)      if (pChannelInfo->instrument_file)
712          free(pChannelInfo->instrument_file);          free(pChannelInfo->instrument_file);
713        if (pChannelInfo->instrument_name)
714            free(pChannelInfo->instrument_name);
715    }
716    
717    void lscp_channel_info_reset ( lscp_channel_info_t *pChannelInfo )
718    {
719        lscp_channel_info_free(pChannelInfo);
720      lscp_channel_info_init(pChannelInfo);      lscp_channel_info_init(pChannelInfo);
721  }  }
722    
# Line 567  void lscp_driver_info_init ( lscp_driver Line 731  void lscp_driver_info_init ( lscp_driver
731      pDriverInfo->parameters  = NULL;      pDriverInfo->parameters  = NULL;
732  }  }
733    
734  void lscp_driver_info_reset ( lscp_driver_info_t *pDriverInfo )  void lscp_driver_info_free ( lscp_driver_info_t *pDriverInfo )
735  {  {
736      if (pDriverInfo->description)      if (pDriverInfo->description)
737          free(pDriverInfo->description);          free(pDriverInfo->description);
738      if (pDriverInfo->version)      if (pDriverInfo->version)
739          free(pDriverInfo->version);          free(pDriverInfo->version);
740      lscp_szsplit_destroy(pDriverInfo->parameters);      lscp_szsplit_destroy(pDriverInfo->parameters);
741    }
742    
743    void lscp_driver_info_reset ( lscp_driver_info_t *pDriverInfo )
744    {
745        lscp_driver_info_free(pDriverInfo);
746      lscp_driver_info_init(pDriverInfo);      lscp_driver_info_init(pDriverInfo);
747  }  }
748    
749    
750    //-------------------------------------------------------------------------
751    // Device info struct functions.
752    
753    void lscp_device_info_init ( lscp_device_info_t *pDeviceInfo )
754    {
755        pDeviceInfo->driver = NULL;
756        lscp_plist_alloc(&(pDeviceInfo->params));
757    }
758    
759    void lscp_device_info_free ( lscp_device_info_t *pDeviceInfo )
760    {
761        if (pDeviceInfo->driver)
762            free(pDeviceInfo->driver);
763        lscp_plist_free(&(pDeviceInfo->params));
764    }
765    
766    void lscp_device_info_reset ( lscp_device_info_t *pDeviceInfo )
767    {
768        lscp_device_info_free(pDeviceInfo);
769        lscp_device_info_init(pDeviceInfo);
770    }
771    
772    
773    //-------------------------------------------------------------------------
774    // Device channel/port info struct functions.
775    
776    void lscp_device_port_info_init ( lscp_device_port_info_t *pDevicePortInfo )
777    {
778        pDevicePortInfo->name = NULL;
779        lscp_plist_alloc(&(pDevicePortInfo->params));
780    }
781    
782    void lscp_device_port_info_free ( lscp_device_port_info_t *pDevicePortInfo )
783    {
784        if (pDevicePortInfo->name)
785            free(pDevicePortInfo->name);
786        lscp_plist_free(&(pDevicePortInfo->params));
787    }
788    
789    void lscp_device_port_info_reset ( lscp_device_port_info_t *pDevicePortInfo )
790    {
791        lscp_device_port_info_free(pDevicePortInfo);
792        lscp_device_port_info_init(pDevicePortInfo);
793    }
794    
795    
796    //-------------------------------------------------------------------------
797    // Parameter struct helper functions.
798    
799    void lscp_param_info_init ( lscp_param_info_t *pParamInfo )
800    {
801        pParamInfo->type          = LSCP_TYPE_NONE;
802        pParamInfo->description   = NULL;
803        pParamInfo->mandatory     = 0;
804        pParamInfo->fix           = 0;
805        pParamInfo->multiplicity  = 0;
806        pParamInfo->depends       = NULL;
807        pParamInfo->defaultv      = NULL;
808        pParamInfo->range_min     = NULL;
809        pParamInfo->range_max     = NULL;
810        pParamInfo->possibilities = NULL;
811    }
812    
813    void lscp_param_info_free ( lscp_param_info_t *pParamInfo )
814    {
815        if (pParamInfo->description)
816            free(pParamInfo->description);
817        lscp_szsplit_destroy(pParamInfo->depends);
818        if (pParamInfo->defaultv)
819            free(pParamInfo->defaultv);
820        if (pParamInfo->range_min)
821            free(pParamInfo->range_min);
822        if (pParamInfo->range_max)
823            free(pParamInfo->range_max);
824        lscp_szsplit_destroy(pParamInfo->possibilities);
825    }
826    
827    void lscp_param_info_reset ( lscp_param_info_t *pParamInfo )
828    {
829        lscp_param_info_free(pParamInfo);
830        lscp_param_info_init(pParamInfo);
831    }
832    
833    
834    //-------------------------------------------------------------------------
835    // Concatenate a parameter list (key='value'...) into a string,
836    // appending a crlf terminator.
837    
838    int lscp_param_concat ( char *pszBuffer, int cchMaxBuffer, lscp_param_t *pParams )
839    {
840        int cchBuffer, cchParam, i;
841    
842        if (pszBuffer == NULL)
843            return 0;
844    
845        cchBuffer = strlen(pszBuffer);
846        for (i = 0; pParams && pParams[i].key && pParams[i].value; i++) {
847            cchParam = strlen(pParams[i].key) + strlen(pParams[i].value) + 4;
848            if (cchBuffer + cchParam + 2 < cchMaxBuffer) {
849                sprintf(pszBuffer + cchBuffer, " %s='%s'", pParams[i].key, pParams[i].value);
850                cchBuffer += cchParam;
851            }
852        }
853        
854        if (cchBuffer + 2 < cchMaxBuffer) {
855            pszBuffer[cchBuffer++] = '\r';
856            pszBuffer[cchBuffer++] = '\n';
857            pszBuffer[cchBuffer ]  = (char) 0;
858        }
859        
860        return cchBuffer;
861    }
862    
863    
864  // end of common.c  // end of common.c
Legend:
Removed from v.158  
changed lines
  Added in v.378
  ViewVC Help
Powered by ViewVC