开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
cdcache.c
资源名称：xtractor.zip　[点击查看]
上传用户：xmgzy123
上传日期：2007-01-07
资源大小：373k
文件大小：25k
源码类别：

SCSI/ASPI

开发平台：

WINDOWS

cdcache.c：源码内容
  1. /*
  2.  * cdcache.c - Copyright (C) 1999 Jay A. Key
  3.  *
  4.  * Interface to CD title/artist/track names cache, and cddb.  Can optionally
  5.  * use cdplayer.ini when internet access is not available.
  6.  *
  7.  * The code to access CDPLAYER.INI was adapted from code submitted by
  8.  * Blair Thompson
  9.  *
  10.  **********************************************************************
  11.  *
  12.  * This program is free software; you can redistribute it and/or modify
  13.  * it under the terms of the GNU Lesser General Public License as published
  14.  * by the Free Software Foundation; either version 2 of the License, or
  15.  * (at your option) any later version.
  16.  *
  17.  * This program is distributed in the hope that it will be useful,
  18.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20.  * GNU General Public License for more details.
  21.  *
  22.  * You should have received a copy of the GNU Lesser General Public License
  23.  * along with this program; if not, write to the Free Software
  24.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  25.  *
  26.  **********************************************************************
  27.  *
  28.  * $Id: cdcache.c,v 1.2 2000/02/25 10:47:37 akey Exp $
  29.  * $Date: 2000/02/25 10:47:37 $
  30.  * $Locker:  $
  31.  * $Log: cdcache.c,v $
  32.  * Revision 1.2  2000/02/25 10:47:37  akey
  33.  * sync'ed with akrip32.dll v0.94
  34.  *
  35.  * Revision 1.6  2000/02/14 09:56:25  akey
  36.  * cleaned up #ifdef _DEBUG code considerably
  37.  *
  38.  * Revision 1.5  2000/02/11 10:00:35  akey
  39.  * added access to cdplayer.ini
  40.  *
  41.  * Revision 1.4  2000/01/31 15:35:40  akey
  42.  * v0.93: added CDDBGetServerList and fixed problem with Win2000 scsi pass through code
  43.  *
  44.  * Revision 1.3  2000/01/06 16:38:35  akey
  45.  * Added missing CDDB_OPT_HTTPPORT
  46.  *
  47.  * Revision 1.2  2000/01/03 12:29:43  akey
  48.  * v0.91 release -- added CDDB and bug fixes
  49.  *
  50.  *
  51.  */
  53. #include <windows.h>
  54. #include <stdio.h>
  55. #include <time.h>
  56. #include <string.h>
  57. #include <stdlib.h>
  58. #include <ctype.h>
  59. #include <winsock.h>
  60. #include "aspilib.h"
  61. #include "cdcache.h"
  64. DWORD CDDBPostCmd( char *cmd, char *retBuf, int retLen );
  65. DWORD CDDBPostCmdProxy( char *cmd, char *retBuf, int retLen );
  66. void urlEncodeString( char *s );
  67. void GetLineFromBuf( char **src, char *tgt, int len );
  68. void processCDDBQuery( char *buf, LPCDDBQUERY lpq );
  69. void SkipHTTPHeaders( char **buf );
  70. int extractCDDBQueryInfo( LPCDDBQUERYITEM lpq, char *linebuf );
  71. void processSites( char *buf, LPCDDBSITELIST lps );
  72. int extractCDDBSiteInfo( LPCDDBSITE s, char *buf );
  73. void getWord( char **inBuf, char *outBuf, int len );
  74. DWORD genCDPlayerIniIndex( HCDROM hCD );
  75. void MSB2DWORD( DWORD *d, BYTE *b );
  76. DWORD getDiskInfoCDPlayerIni( LPCDDBQUERYITEM lpq, char *szCDDBEntry, int maxLen );
  77. BOOL isCDinCDPlayerIni( char *s );
  78. void addCDPlayerCDDBIndex( DWORD cdpIdx, DWORD cddbId, DWORD numTracks );
  79. void writeCDPlayerIniEntry( LPCDDBQUERYITEM lpq, char *szCDDBEntry );
  82. extern CDHANDLEREC *cdHandles;
  83. extern HANDLE *cdMutexes;
  84. extern HANDLE hCacheMutex;
  85. extern CRITICAL_SECTION csCache;
  87. extern CRITICAL_SECTION getHandle;
  88. extern int alErrCode;
  89. extern BYTE alAspiErr;
  91. extern DWORD (*pfnSendASPI32Command)(LPSRB);
  93. //static BOOL bCacheInitMutex = FALSE;
  94. static BOOL bCacheInit = FALSE;
  96. static char szCacheDir[MAX_PATH+1];
  97. //static HANDLE hCacheMutex = NULL;
  98. //static CRITICAL_SECTION csCache;
  100. static char szCDPlayerIni[] = "cdplayer.ini";
  101. static char szProxyAddr[256] = "";
  102. static int  iProxyPort = 0;
  103. static char szCDDBServer[256] = "www.freedb.org";
  104. static BOOL bUseProxy = FALSE;
  105. static char szAgent[61] = "akrip32dll 0.91";
  106. static char szUser[65] = "user@akrip.sourceforge.net";
  107. static char szCGI[81] = "/~cddb/cddb.cgi";
  108. static int  iHTTPPort = 80;
  109. static BOOL bUseCDPlayerIni = TRUE;
  110. static DWORD dwCDDB2CDPlayer[20][3];
  111. static int iNextIndex = -1;
  114. DWORD CDDBSum( DWORD n )
  115. {
  116.   DWORD retVal = 0;
  118.   while( n > 0 )
  119.     {
  120.       retVal += ( n % 10 );
  121.       n /= 10;
  122.     }
  124.   return retVal;
  125. }
  128. /*
  129.  * Computes the CDDBID for the CD in the drive represented by hCD.
  130.  * Data which can be used to construct a CDDB query is stored in the 
  131.  * array pID.
  132.  *   pID[0] = CDDBID
  133.  *   pID[1] = number of tracks
  134.  *   pID[2..(2+n)] = starting MSF offset of tracks on CD
  135.  * pID will need to have (at least) n+3 entries, where n is the number
  136.  * of tracks on the CD.  102 should always be enough.  Note that the lead-out
  137.  * track is included.
  138.  */
  139. DWORD GetCDDBDiskID( HCDROM hCD, DWORD *pID, int numEntries )
  140. {
  141.   TOC toc;
  142.   TOCTRACK *t1, *t2;
  143.   int idx = (int)hCD - 1;
  144.   DWORD t;
  145.   DWORD n;
  146.   int i;
  147.   int j;
  148.   BOOL bMSF;
  150.   *pID = 0;
  152.   if ( (idx<0) || (idx>=MAXCDHAND) || !cdHandles[idx].used )
  153.     {
  154.       alErrCode = ALERR_INVHANDLE;
  155.       return SS_ERR;
  156.     }
  158.   if ( WaitForSingleObject( cdMutexes[idx], TIMEOUT ) != WAIT_OBJECT_0 )
  159.     {
  160.       alErrCode = ALERR_LOCK;
  161.       return SS_ERR;
  162.     }
  164.   bMSF = cdHandles[idx].bMSF;
  165.   cdHandles[idx].bMSF = TRUE;
  167.   memset( &toc, 0, sizeof(toc) );
  168.   ReadTOC( hCD, &toc );
  170.   n = t = 0;
  171.   for( j = 2, i = toc.firstTrack - 1; i < toc.lastTrack; i++, j++ )
  172.     {
  173.       t1 = &(toc.tracks[i]);
  174.       pID[j] = (((t1->addr[1]*60)+t1->addr[2])*75)+t1->addr[3];
  175.       n += CDDBSum( 60 * toc.tracks[i].addr[1] + toc.tracks[i].addr[2] );
  176.     }
  178.   t2 = &(toc.tracks[toc.lastTrack-toc.firstTrack+1]);
  179.   t = 60 * t2->addr[1] + t2->addr[2];
  180.   t2 = &(toc.tracks[0]);
  181.   t -= ( 60 * t2->addr[1] + t2->addr[2] );
  182.   pID[toc.lastTrack+2] = t;
  184. #if 0
  185.   // fudge the total time to generate inexact matches for testing
  186.   t += 2;
  187. #endif
  189.   pID[1] = toc.lastTrack - toc.firstTrack + 1;
  191.   *pID = ((n%0xFF) << 24) | (t << 8) | (toc.lastTrack - toc.firstTrack + 1);
  193.   cdHandles[idx].bMSF = bMSF;
  195.   n = genCDPlayerIniIndex( hCD );
  197.   addCDPlayerCDDBIndex( n, pID[0], pID[1] );
  199.   ReleaseMutex( cdMutexes[idx] );
  200.   return SS_COMP;
  201. }
  204. BOOL InitCache( LPCTSTR lpszDir )
  205. {
  206.   if ( bCacheInit )
  207.     return FALSE;
  209.   if ( !lpszDir )
  210.     lpszDir = "";
  211.   strncpy( szCacheDir, lpszDir, MAX_PATH+1 );
  213.   bCacheInit = TRUE;
  214.   return TRUE;
  215. }
  218. /*
  219.  * Sends an HTTP POST command and waits for a response.  The response is
  220.  * copied to retBuf.  Uses a proxy.  Returns the number of bytes copied to
  221.  * retBuf.  Before returning, it should strip the HTTP header from the info
  222.  * if present.
  223.  */
  224. DWORD CDDBPostCmdProxy( char *cmd, char *retBuf, int retLen )
  225. {
  226.   WSADATA wsaData;
  227.   SOCKET s;
  228.   struct hostent *h;
  229.   struct sockaddr_in sin;
  230.   int i;
  231.   char *postcmd, *p;
  232.   DWORD retVal = 0;
  234.   p = retBuf;
  235.   ZeroMemory( p, retLen );
  236.   retLen--;                 // reserve room for the terminating NULL
  238.   WSAStartup( MAKEWORD(1,1), &wsaData );
  240.   s = socket( AF_INET, SOCK_STREAM, 0 );
  241.   h = gethostbyname( szProxyAddr );
  243.   if ( !h )
  244.     {
  245. #ifdef _DEBUG
  246.       dbprintf( "akrip32: CDDBPostCmdProxy: unable to resolve hostname" );
  247. #endif
  248.       return 0;
  249.     }
  251.   sin.sin_family = AF_INET;
  252.   sin.sin_port = htons( iProxyPort );
  253.   memcpy( &sin.sin_addr, h->h_addr, h->h_length );
  255.   i = connect( s, (struct sockaddr *)&sin, sizeof(sin) );
  257.   p = postcmd = (char *)GlobalAlloc( GPTR, lstrlen(cmd) + 512 );
  259.   wsprintf( postcmd, "POST http://%s%s HTTP/1.0rnContent-Type: application/x-www-form-urlencodedrnUser-Agent: AKRip090rn", szCDDBServer, szCGI );
  260.   p += lstrlen( postcmd );
  261.   wsprintf( p, "Content-Length: %drnrn", lstrlen( cmd ) + 2 );
  262.   strcat( p, cmd );
  263.   strcat( p, "rn" );
  265. #if 0
  266.   i = 120;
  267.   i = setsockopt( s, IPPROTO_TCP, SO_SNDTIMEO, &i, sizeof(int) );
  268.   if ( i == SOCKET_ERROR )
  269.     dbprintf( "Error setting rcv timeout on socket" );
  270.   else
  271.     dbprintf( "Receive socket timeout set" );
  272. #endif
  274.   send( s, postcmd, lstrlen( postcmd ), 0 );
  276.   p = retBuf;
  277.   ZeroMemory( p, retLen );
  278.   i = -1;
  279.   while( (i != 0) && (retLen >= 128) )
  280.     {
  281.       i = recv( s, p, 128, 0 );
  282.       p += i;
  283.       retLen -= i;
  284.       retVal += (DWORD)i;
  285.       if ( i < 0 )
  286. i = 0;
  287.     }
  289.   closesocket( s );
  290.   
  291.   GlobalFree( (HGLOBAL)postcmd );
  292.   WSACleanup();
  294.   return retVal;
  295. }
  298. /*
  299.  * Sends an HTTP POST command and waits for a response.  The response is
  300.  * copied to retBuf.  Returns the number of bytes copied to retBuf.
  301.  */
  302. DWORD CDDBPostCmd( char *cmd, char *retBuf, int retLen )
  303. {
  304.   WSADATA wsaData;
  305.   SOCKET s;
  306.   struct hostent *h;
  307.   struct sockaddr_in sin;
  308.   int i;
  309.   char *postcmd, *p;
  310.   DWORD retVal = 0;
  312.   p = retBuf;
  313.   ZeroMemory( p, retLen );
  314.   retLen--;                 // reserve room for the terminating NULL
  316.   WSAStartup( MAKEWORD(1,1), &wsaData );
  318.   s = socket( AF_INET, SOCK_STREAM, 0 );
  319.   h = gethostbyname( szCDDBServer );
  321.   if ( !h )
  322.     return 0;
  324.   sin.sin_family = AF_INET;
  325.   sin.sin_port = htons( iHTTPPort );
  326.   memcpy( &sin.sin_addr, h->h_addr, h->h_length );
  328.   i = connect( s, (struct sockaddr *)&sin, sizeof(sin) );
  330.   p = postcmd = (char *)GlobalAlloc( GPTR, lstrlen(cmd) + 512 );
  331.   
  332.   wsprintf( p, "GET %s?", szCGI );
  333.   strcat( p, cmd );
  334.   strcat( p, "rn" );
  336.   send( s, postcmd, lstrlen( postcmd ), 0 );
  338.   p = retBuf;
  339.   ZeroMemory( p, retLen );
  340.   i = -1;
  341.   while( (i != 0) && (retLen >= 128) )
  342.     {
  343.       i = recv( s, p, 128, 0 );
  344.       p += i;
  345.       retLen -= i;
  346.       retVal += (DWORD)i;
  347.       if ( i < 0 )
  348. i = 0;
  349.     }
  351.   closesocket( s );
  352.   
  353.   GlobalFree( (HGLOBAL)postcmd );
  354.   WSACleanup();
  356.   return retVal;
  357. }
  360. /*
  361.  * Queries the CDDB for a given disk.
  362.  * Returns SS_COMP on success, SS_ERR on error.  numEntries on entry contains
  363.  * the number of elements in the lpq array, and on return is set to the 
  364.  * number of entries returned.
  365.  *
  366.  * If the no items are returned, or if no network connection is available,
  367.  * returns one item with category "cdplayerini" and the index stored in
  368.  * cddbId;
  369.  */
  370. DWORD CDDBQuery( HCDROM hCD, LPCDDBQUERY lpq )
  371. {
  372.   //int numRead = 0;
  373.   LPDWORD pdwId;
  374.   char *cmd, *p, *retBuf;
  375.   int i;
  377.   if ( !lpq )
  378.     {
  379.       return SS_ERR;
  380.     }
  382.   pdwId = GlobalAlloc( GPTR, 103 * sizeof(DWORD) );
  383.   cmd = GlobalAlloc( GPTR, 1024 );
  384.   retBuf = GlobalAlloc( GPTR, 2048 );
  385.   if ( !cmd || !pdwId || !retBuf )
  386.     {
  387.       if ( cmd ) GlobalFree( (HGLOBAL)cmd );
  388.       if ( pdwId ) GlobalFree( (HGLOBAL)pdwId );
  389.       if ( retBuf ) GlobalFree( (HGLOBAL)retBuf );
  390.       lpq->num = 0;
  391.       return SS_ERR;
  392.     }
  394.   // Generate the cddb ID for the disc
  395.   if ( GetCDDBDiskID( hCD, pdwId, 102 ) == SS_COMP )
  396.     {
  397.       // Generate a query string
  398.       p = cmd;
  399.       wsprintf( p, "cmd=cddb+query+%08x+%d+", pdwId[0], pdwId[1] );
  400.       p += lstrlen( p );
  401.       for( i = 0; i < pdwId[1]; i++ )
  402. {
  403.   wsprintf( p, "%d+", pdwId[i+2] );
  404.   p += lstrlen(p);
  405. }
  406.       wsprintf( p, "%d&hello=%s+%s&proto=3",
  407. pdwId[pdwId[1]+2], szUser, szAgent );
  408.       urlEncodeString( p );
  410.       // send the query string
  411.       if ( bUseProxy )
  412. CDDBPostCmdProxy( cmd, retBuf, 2048 );
  413.       else
  414. CDDBPostCmd( cmd, retBuf, 2048 );
  416.       // process the returned data (if any)
  417.       processCDDBQuery( retBuf, lpq );
  419.       // fall back to cdplayer.ini if no items matched
  420.       if ( (lpq->num == 0) && bUseCDPlayerIni )
  421. {
  422.   pdwId[0] = genCDPlayerIniIndex( hCD );
  423.   wsprintf( retBuf, "%X", pdwId[0] );
  424.   if ( isCDinCDPlayerIni( retBuf ) )
  425.     {
  426.       wsprintf( lpq->q[0].cddbId, "%X", pdwId[0] );
  427.       lstrcpy( lpq->q[0].categ, "cdplayerini" );
  428.       lpq->q[0].bExact = TRUE;
  429.       lpq->num = 1;
  430.     }
  431. }
  432.       // else if we have multiple/partial matches from CDDB, we need to 
  433.       // associate all of the cddbId values with the cdPlayer.ini index
  434.       else if ( (lpq->num > 1) && bUseCDPlayerIni )
  435. {
  436.   pdwId[2] = genCDPlayerIniIndex( hCD );
  437.   for( i = 0; i < lpq->num; i++ )
  438.     {
  439.       pdwId[0] = (DWORD)strtoul( lpq->q[i].cddbId, NULL, 16 );
  440.       addCDPlayerCDDBIndex( pdwId[2], pdwId[0], pdwId[1] );
  441.     }
  442. }
  443.     }
  445.   GlobalFree( (HGLOBAL)pdwId );
  446.   GlobalFree( (HGLOBAL)cmd );
  447.   GlobalFree( (HGLOBAL)retBuf );
  449.   return SS_COMP;
  450. }
  453. void CDDBSetOption( int what, char *szVal, int iVal )
  454. {
  455.   switch( what )
  456.     {
  457.     case CDDB_OPT_PROXY:
  458.       if ( szVal )
  459. lstrcpyn( szProxyAddr, szVal, 255 );
  460.       szProxyAddr[255] = 0;
  461.       break;
  463.     case CDDB_OPT_SERVER:
  464.       if ( szVal )
  465. lstrcpyn( szCDDBServer, szVal, 255 );
  466.       szCDDBServer[255] = 0;
  467.       break;
  469.     case CDDB_OPT_CGI:
  470.       if ( szVal )
  471. lstrcpyn( szCGI, szVal, 80 );
  472.       szCGI[80] = 0;
  473.       break;
  475.     case CDDB_OPT_PROXYPORT:
  476.       iProxyPort = iVal;
  477.       break;
  479.     case CDDB_OPT_AGENT:
  480.       if ( szVal )
  481. lstrcpyn( szAgent, szVal, 60 );
  482.       szAgent[60] = 0;
  483.       urlEncodeString( szAgent );
  484.       break;
  486.     case CDDB_OPT_USER:
  487.       if ( szVal )
  488. lstrcpyn( szUser, szVal, 64 );
  489.       szUser[64] = 0;
  490.       urlEncodeString( szUser );
  491.       break;
  493.     case CDDB_OPT_USEPROXY:
  494.       bUseProxy = (BOOL)iVal;
  495.       break;
  497.     case CDDB_OPT_HTTPPORT:
  498.       iHTTPPort = iVal;
  499.       break;
  501.     case CDDB_OPT_USECDPLAYERINI:
  502.       bUseCDPlayerIni = (BOOL)iVal;
  503.       break;
  504.     }
  505. }
  508. void urlEncodeString( char *s )
  509. {
  510.   if ( !s || !*s )
  511.     return;
  513.   while( *++s )
  514.     {
  515.       if ( (*s == '@') || (*s == ' ') )
  516. *s = '+';
  517.     }
  518. }
  521. /*
  522.  * Process the return buffer from a cddb query.  Verify that the return code
  523.  * is one that we expect (200, 211, 202, 403, 409).
  524.  */
  525. void processCDDBQuery( char *buf, LPCDDBQUERY lpq )
  526. {
  527.   int total = 0;
  528.   int iRetCode, i;
  529.   int maxLines = 100;
  530.   char retCode[4] = "100";
  531.   char linebuf[81];
  532.   char *p = buf;
  533.   FILE *fp;
  535.   fp = fopen( "retbuf.txt", "wb" );
  536.   fwrite( p, 1, lstrlen( p ), fp );
  538.   SkipHTTPHeaders( &p );
  540.   GetLineFromBuf( &p, linebuf, 81 );
  542.   strncpy( retCode, linebuf, 3 );
  543.   iRetCode = atoi( retCode );
  545.   switch( iRetCode )
  546.     {
  547.     case 200:
  548.       // one exact match
  549.       if ( extractCDDBQueryInfo( &lpq->q[0], linebuf+4 ) )
  550. {
  551.   lpq->q[0].bExact = TRUE;
  552.   total++;
  553. }
  554.       break;
  556.     case 211:
  557.       // inexact match(es)
  558.       i = 0;
  559.       while ( p && lpq->num && (maxLines-- > 0) )
  560. {
  561.   GetLineFromBuf( &p, linebuf, 81 );
  562.   if ( !strcmp( linebuf, "." ) )
  563.     break;
  564.   if ( extractCDDBQueryInfo( &lpq->q[i], linebuf ) )
  565.     {
  566.       lpq->q[i].bExact = FALSE;
  567.       total++;
  568.       i++;
  569.       lpq->num--;
  570.     }
  571. }
  572.       break;
  574.     case 202:
  575.       // no matches;
  576.       break;
  578.     case 403:
  579.       // database entry corrupt
  580.       break;
  582.     case 409:
  583.       // no handshake (probably won't happen with HTTP)
  584.       break;
  585.     }
  587.   lpq->num = total;
  589.   fclose( fp );
  590. }
  593. void GetLineFromBuf( char **src, char *tgt, int len )
  594. {
  595.   char *s, *t;
  597.   if ( !src || !*src || !tgt )
  598.     {
  599.       return;
  600.     }
  602.   ZeroMemory( tgt, len );
  604.   s = strstr( *src, "rn" );
  605.   if ( !s )
  606.     {
  607.       *src += lstrlen( *src );
  608.       return;
  609.     }
  611.   lstrcpyn( tgt, *src, len-1 );
  612.   t = strstr( tgt, "rn" );
  613.   if ( t && ((t - tgt) < len) )
  614.     tgt[t-tgt] = '';
  615.   
  616.   *src = s + 2;
  617. }
  620. /*
  621.  * extracts the category, cddbid and title(artist/album) from linebuf and 
  622.  * stores it in lpq
  623.  */
  624. int extractCDDBQueryInfo( LPCDDBQUERYITEM lpq, char *linebuf )
  625. {
  626.   int i;
  627.   char *p = linebuf;
  628.   char *t;
  630.   if ( !lpq || !linebuf || !*linebuf )
  631.     return 0;
  633.   ZeroMemory( lpq, sizeof(CDDBQUERY) );
  635.   // extract the category
  636.   i = 11;
  637.   t = lpq->categ;
  638.   while( *p && (*p != ' ') && i )
  639.     {
  640.       *t++ = *p++;
  641.       i--;
  642.     }
  643.   if ( *p != ' ' )
  644.     {
  645.       return 0;
  646.     }
  648.   // extract the cddbid
  649.   while ( *p && (*++p == ' ') );    // skip space
  650.   i = 8;
  651.   t = lpq->cddbId;
  652.   while ( *p && ( isxdigit( *p ) ) && i )
  653.     {
  654.       *t++ = *p++;
  655.       i--;
  656.     }
  658.   if ( *p != ' ' )
  659.     {
  660.       return 0;
  661.     }
  663.   // get artist and title
  664.   while ( *p && (*++p == ' ') );    // skip space
  665.   i = 80;
  666.   t = lpq->artist;
  667.   t[0] = '';
  668.   while ( *p && (*p != '/') && i )
  669.     {
  670.       *t++ = *p++;
  671.       i--;
  672.     }
  673.   i = lstrlen( lpq->artist );
  674.   if ( i > 0 )
  675.     {
  676.       if ( lpq->artist[i-1] == ' ' )
  677. lpq->artist[i-1] = '';
  678.     }
  680.   if ( *p != '/' )
  681.     {
  682.       return 0;
  683.     }
  685.   while ( *p && (*++p == ' ') );    // skip space
  687.   t = lpq->title;
  688.   lstrcpyn( t, p, 80 );
  689.   i = lstrlen( lpq->title );
  690.   if ( i > 0 )
  691.     {
  692.       if ( lpq->title[i-1] == 'r' || lpq->title[i-1] == 'n' )
  693. lpq->title[i-1] = '';
  694.     }
  697.   return 1;
  698. }
  701. void SkipHTTPHeaders( char **buf )
  702. {
  703.   char *p;
  705.   if ( !buf || !*buf || !**buf )
  706.     return;
  708.   p = *buf;
  710.   if ( strncmp( p, "HTTP", 4 ) )
  711.     {
  712.       return;
  713.     }
  715.   p = strstr( p, "rnrn" );
  716.   if ( p )
  717.     {
  718.       p += 4;
  719.       *buf = p;
  720.     }
  721. }
  724. /*
  725.  * Returns the CDDB entry verbatim from the CDDB database.  If not large
  726.  * enough, no data is copied.  Verifies that the return code from CDDB is
  727.  * 210 -- CDDB entry follows...
  728.  *
  729.  * If the use of CDPLAYER.INI is enabled and the category is for the query
  730.  * is "cdplayerini", then an attempt is made to read the information from
  731.  * CDPLAYER.INI.
  732.  */
  733. DWORD CDDBGetDiskInfo( LPCDDBQUERYITEM lpq, char *szCDDBEntry, int maxLen )
  734. {
  735.   char *cmd, *p;
  736.   char *retBuf;
  737.   DWORD retVal = SS_ERR;
  739.   if ( !lpq || !szCDDBEntry )
  740.     return retVal;
  742.   if ( !lstrcmp( lpq->categ, "cdplayerini" ) )
  743.     return getDiskInfoCDPlayerIni( lpq, szCDDBEntry, maxLen );
  745.   cmd = (char *)GlobalAlloc( GPTR, 512 );
  746.   retBuf = (char *)GlobalAlloc( GPTR, maxLen );
  748.   p = cmd;
  749.   wsprintf( p, "cmd=cddb+read+%s+%s", lpq->categ, lpq->cddbId );
  750.   p += lstrlen( p );
  751.   wsprintf( p, "&hello=%s+%s&proto=3", szUser, szAgent );
  752.   urlEncodeString( p );
  754.       // send the query string
  755.   if ( bUseProxy )
  756.     CDDBPostCmdProxy( cmd, retBuf, maxLen );
  757.   else
  758.     CDDBPostCmd( cmd, retBuf, maxLen );
  760.   // strip any HTTP headers
  761.   p = retBuf;
  762.   SkipHTTPHeaders( &p );
  764.   if ( !strncmp( p, "210", 3 ) )
  765.     {
  766.       p = strstr( p, "n" );
  767.       if ( p )
  768. {
  769.   p += 1;  // skip the 'n'
  770.   if ( lstrlen(p) < maxLen )
  771.     {
  772.       strcpy( szCDDBEntry, p );
  773.       retVal = SS_COMP;
  774.       // should we add it to cdplayer.ini?
  775.       if ( bUseCDPlayerIni && *p )
  776. {
  777.   writeCDPlayerIniEntry( lpq, p );
  778. }
  779.     }
  780. }
  781.     }
  783.   GlobalFree( (HGLOBAL)cmd );
  784.   GlobalFree( (HGLOBAL)retBuf );
  786.   return retVal;
  787. }
  791. DWORD CDDBGetServerList( LPCDDBSITELIST lps )
  792. {
  793.   char *cmd, *p;
  794.   char *retBuf;
  795.   DWORD retVal = SS_ERR;
  797.   if ( !lps || !lps->s )
  798.     return retVal;
  800.   cmd = (char *)GlobalAlloc( GPTR, 512 );
  801.   retBuf = (char *)GlobalAlloc( GPTR, 4096 );
  803.   p = cmd;
  804.   wsprintf( p, "cmd=sites&hello=%s+%s&proto=3", szUser, szAgent );
  805.   urlEncodeString( p );
  807.   // send the query string
  808.   if ( bUseProxy )
  809.     CDDBPostCmdProxy( cmd, retBuf, 4096 );
  810.   else
  811.     CDDBPostCmd( cmd, retBuf, 4096 );
  813.   if ( retBuf[0] )
  814.     {
  815.       // look for the "210 OK, site information..." message
  816.       processSites( retBuf, lps );
  817.       retVal = SS_COMP;
  818.     }
  820.   GlobalFree( (HGLOBAL)cmd );
  821.   GlobalFree( (HGLOBAL)retBuf );
  823.   return retVal;
  824. }
  828. void processSites( char *buf, LPCDDBSITELIST lps )
  829. {
  830.   char linebuf[81];
  831.   char retCode[4] = "";
  832.   char *p;
  833.   int total, iRetCode;
  834.   int maxLines = 100;
  836.   // strip any HTTP headers
  837.   p = buf;
  838.   SkipHTTPHeaders( &p );
  840.   GetLineFromBuf( &p, linebuf, 81 );
  842.   strncpy( retCode, linebuf, 3 );
  843.   iRetCode = atoi( retCode );
  845.   total = 0;
  847.   switch( iRetCode )
  848.     {
  849.     case 210:   // normal return code, site list follows
  850.       while ( p && lps->num && (maxLines-- > 0) )
  851. {
  852.   GetLineFromBuf( &p, linebuf, 81 );
  853.   if ( !strcmp( linebuf, "." ) )
  854.     break;
  855.   if ( extractCDDBSiteInfo( &lps->s[total], linebuf ) )
  856.     {
  857.       total++;
  858.       lps->num--;
  859.     }
  860. }
  861.       break;
  863.     case 401: // no site info available
  864.       break;
  865.     }
  867.   lps->num = total;
  868. }
  872. int extractCDDBSiteInfo( LPCDDBSITE lps, char *linebuf )
  873. {
  874.   char *p;
  875.   char buf[6];
  877.   if ( !lps || !linebuf || !*linebuf )
  878.     return 0;
  880.   ZeroMemory( lps, sizeof(CDDBSITE) );
  882.   p = linebuf;
  884.   // extract the server
  885.   getWord( &p, lps->szServer, 81 );
  886.   if ( *p != ' ' )
  887.     return 0;
  889.   // extract the protocol
  890.   getWord( &p, buf, 6 );
  891.   if ( *p != ' ' )
  892.     return 0;
  893.   if ( !lstrcmpi( buf, "http" ) )
  894.     lps->bHTTP = TRUE;
  896.   // extract the port number
  897.   getWord( &p, buf, 6 );
  898.   if ( *p != ' ' )
  899.     return 0;
  900.   lps->iPort = atoi( buf );
  901.   if ( lps->bHTTP && !lps->iPort )
  902.     lps->iPort = 80;
  904.   // extract the CGI
  905.   getWord( &p, lps->szCGI, 81 );
  906.   if ( *p != ' ' )
  907.     return 0;
  909.   // extract north coordinate
  910.   getWord( &p, lps->szNorth, 16 );
  911.   if ( *p != ' ' )
  912.     return 0;
  914.   // extract north coordinate
  915.   getWord( &p, lps->szSouth, 16 );
  916.   if ( *p != ' ' )
  917.     return 0;
  919.   // extract the location
  920.   while( *p && (*p == ' ') ) p++; 
  921.   lstrcpyn( lps->szLocation, p, 80 );
  923.   return -1;
  924. }
  927. void getWord( char **inBuf, char *outBuf, int len )
  928. {
  929.   char *p = *inBuf;
  931.   ZeroMemory( outBuf, len );
  932.   len--;
  934.   // skip space
  935.   while( *p && (*p == ' ') ) p++;
  937. #if 0
  938.   while( TRUE )
  939.     {
  940.       if ( !*p )
  941. break;
  942.       if ( !isalnum( *p ) && (*p != '.') )
  943. break;
  944.       if ( !len )
  945. break;
  946.       *outBuf++ = *p++;
  947.       len--;
  948.     }
  949. #else
  950.   while( *p &&
  951.  ( isalnum( *p ) || ( *p == '.') || ( *p == '/' ) || ( *p == '~' ) ) &&
  952.  len )
  953.     {
  954.       *outBuf++ = *p++;
  955.       len--;
  956.     }
  957. #endif
  959.   *inBuf = p;
  960. }
  963. DWORD genCDPlayerIniIndex( HCDROM hCD )
  964. {
  965.   DWORD retVal = 0;
  966.   BOOL bMSF;
  967.   int idx = (int)hCD - 1;
  968.   int i;
  969.   TOC toc;
  970.   DWORD dwAddr;
  972.   bMSF = cdHandles[idx].bMSF;
  973.   cdHandles[idx].bMSF = TRUE;
  975.   memset( &toc, 0, sizeof(toc) );
  976.   ReadTOC( hCD, &toc );
  978.   for( i = 0; i <= (toc.lastTrack - toc.firstTrack); i++ )
  979.     {
  980.       MSB2DWORD( &dwAddr, toc.tracks[i].addr );
  981.       retVal += dwAddr;
  982.     }
  984.   return retVal;
  985. }
  988. void MSB2DWORD( DWORD *d, BYTE *b )
  989. {
  990.   DWORD retVal;
  992.   retVal = (DWORD)b[0];
  993.   retVal = (retVal<<8) + (DWORD)b[1];
  994.   retVal = (retVal<<8) + (DWORD)b[2];
  995.   retVal = (retVal<<8) + (DWORD)b[3];
  997.   *d = retVal;
  998. }
  1001. DWORD getDiskInfoCDPlayerIni( LPCDDBQUERYITEM lpq, char *szCDDBEntry, int maxLen )
  1002. {
  1003.   UINT i, numRead;
  1004.   char buf[256];
  1005.   char idx[5];
  1006.   char defaultName[13];
  1007.   char *p;
  1009.   if ( !lpq || !szCDDBEntry )
  1010.     return SS_ERR;
  1012.   numRead = GetPrivateProfileInt( lpq->cddbId, "NUMTRACKS", 0, szCDPlayerIni );
  1013.   if ( numRead )
  1014.     {
  1015.       lstrcpy( lpq->categ, "rock" );
  1016.       lpq->bExact = TRUE;
  1017.       GetPrivateProfileString( lpq->cddbId, "ARTIST", "", buf, 256, szCDPlayerIni );
  1018.       lstrcpyn( lpq->artist, buf, 80 ); lpq->artist[80] = '';
  1019.       GetPrivateProfileString( lpq->cddbId, "TITLE", "", buf, 256, szCDPlayerIni );
  1020.       lstrcpyn( lpq->title, buf, 80 ); lpq->title[80] = '';
  1021.       p = szCDDBEntry;
  1022.       wsprintf( buf, "DTITLE=%s / %srn", lpq->artist, lpq->title );
  1023.       if ( maxLen > lstrlen(buf) )
  1024. {
  1025.   lstrcpy( p, buf );
  1026.   p += lstrlen( buf );
  1027.   maxLen -= lstrlen( buf );
  1028. }
  1029.       for( i = 0; i < numRead; i++ )
  1030. {
  1031.   wsprintf( idx, "%d", i );
  1032.   wsprintf( defaultName, "Track %d", i+1 );
  1033.   GetPrivateProfileString( lpq->cddbId, idx, defaultName, buf, 256, szCDPlayerIni );
  1034.   if ( maxLen > (lstrlen( buf )+12) )
  1035.     {
  1036.       wsprintf( p, "TTITLE%d=%srn", i, buf );
  1037.       maxLen -= lstrlen( p );
  1038.       p += lstrlen( p );
  1039.     }
  1040.   else
  1041.     break;
  1042. }
  1043.     }
  1045.   if ( numRead )
  1046.     return SS_COMP;
  1047.   return SS_ERR;
  1048. }
  1051. BOOL isCDinCDPlayerIni( char *s )
  1052. {
  1053.   UINT uiVal;
  1055.   uiVal = GetPrivateProfileInt( s, "NUMTRACKS", 0, "cdplayer.ini" );
  1057.   return (BOOL)uiVal;
  1058. }
  1061. void addCDPlayerCDDBIndex( DWORD cdpIdx, DWORD cddbId, DWORD numTracks )
  1062. {
  1063.   if ( iNextIndex == -1 )
  1064.     ZeroMemory( dwCDDB2CDPlayer, sizeof(dwCDDB2CDPlayer) );
  1066.   if ( (++iNextIndex % 20) == 0 )
  1067.     iNextIndex = 0;
  1069.   dwCDDB2CDPlayer[iNextIndex][0] = cdpIdx;        // cdplayer.ini index
  1070.   dwCDDB2CDPlayer[iNextIndex][1] = cddbId;        // cddb id
  1071.   dwCDDB2CDPlayer[iNextIndex][2] = numTracks;     // number of tracks
  1072. }
  1075. DWORD CDDBIndex2CDPlayerIni( char *szCDDBId, DWORD *dwRetVal, DWORD *numTracks )
  1076. {
  1077.   int i;
  1078.   DWORD dwIdx = (DWORD)strtoul( szCDDBId, NULL, 16 );
  1080.   for( i = 0; i < 20; i++ )
  1081.     {
  1082.       if ( dwCDDB2CDPlayer[i][1] == dwIdx )
  1083. {
  1084.   *dwRetVal = dwCDDB2CDPlayer[i][0];
  1085.   *numTracks = dwCDDB2CDPlayer[i][2];
  1086.   return *dwRetVal;
  1087. }
  1088.     }
  1090.   return 0;
  1091. }
  1094. /*
  1095.  * Stores a CDDB entry in cdplayer.ini.  NOTE: the buffer pointed to
  1096.  * by szCDDBEntry may be modified by this function.  Do not count on the
  1097.  * buffer being unmodified!!!
  1098.  */
  1099. void writeCDPlayerIniEntry( LPCDDBQUERYITEM lpq, char *szCDDBEntry )
  1100. {
  1101.   DWORD dwCDPlayerIdx, dwNumTracks;
  1102.   char section[24];
  1103.   char buf[128];
  1104.   char *p1, *p2;
  1106.   CDDBIndex2CDPlayerIni( lpq->cddbId, &dwCDPlayerIdx, &dwNumTracks );
  1107.   if ( !dwCDPlayerIdx )
  1108.     {
  1109.       return;
  1110.     }
  1112.   wsprintf( section, "%X", dwCDPlayerIdx );
  1113.   WritePrivateProfileString( section, "EntryType", "1", szCDPlayerIni );
  1114.   WritePrivateProfileString( section, "artist", lpq->artist, szCDPlayerIni );
  1115.   WritePrivateProfileString( section, "title", lpq->title, szCDPlayerIni );
  1116.   WritePrivateProfileString( section, "genre", lpq->categ, szCDPlayerIni );
  1117.   wsprintf( buf, "%d", dwNumTracks );
  1118.   WritePrivateProfileString( section, "numtracks", buf, szCDPlayerIni );
  1120.   while (*szCDDBEntry)
  1121.     {
  1122.       GetLineFromBuf( &szCDDBEntry, buf, 128 );
  1123.       if ( !szCDDBEntry )
  1124. break;
  1125.       if ( !strncmp( "TTITLE", buf, 6 ) )
  1126. {
  1127.   p1 = buf + 6;
  1128.   p2 = strstr( buf, "=" );
  1129.   if ( *p1 && p2 )
  1130.     {
  1131.       *p2 = '';
  1132.       p2++;
  1133.       WritePrivateProfileString( section, p1, p2, szCDPlayerIni );
  1134.     }
  1135. }
  1136.     }
  1137. }