C语言中的谷歌自定义搜索结果

我正在尝试用

C

编写一个简单的客户端，它将与谷歌搜索API接口并返回搜索结果。我能够发送一个搜索请求，并得到一个200 OK代码和一些标题文本的回复，但没有搜索结果。我做错什么了吗

这是我的密码：

#include sys/socket.h
#include sys/types.h
#include netinet/in.h
#include netdb.h
#include stdio.h
#include string.h
#include stdlib.h
#include unistd.h
#include errno.h
#include openssl/rand.h
#include openssl/ssl.h
#include openssl/err.h

// Simple structure to keep track of the handle, and
// of what needs to be freed later.
typedef struct {
    int socket;
    SSL *sslHandle;
    SSL_CTX *sslContext;
} connection;

// For this example, we'll be testing on openssl.org
#define KEY     "/customsearch/v1?key=AIzaSyAOdB5MgAEmvzglw05rR1OPYEYgFuZrT9o&cx=003397780648636422832:u25rx3s92ro&q="
#define SERVER  "www.googleapis.com"
#define PORT 443

// Establish a regular tcp connection
int tcpConnect ()
{
  int error, handle;
  struct hostent *host;
  struct sockaddr_in server;

  host = gethostbyname (SERVER);
  handle = socket (AF_INET, SOCK_STREAM, 0);
  if (handle == -1)
    {
      perror ("Socket");
      handle = 0;
    }
  else
    {
      server.sin_family = AF_INET;
      server.sin_port = htons (PORT);
      server.sin_addr = *((struct in_addr *) host->h_addr);
      bzero (&(server.sin_zero), 8);

      error = connect (handle, (struct sockaddr *) &server,
                       sizeof (struct sockaddr));
      if (error == -1)
        {
          perror ("Connect");
          handle = 0;
        }
    }

  return handle;
}

// Establish a connection using an SSL layer
connection *sslConnect (void)
{
  connection *c;

  c = malloc (sizeof (connection));
  c->sslHandle = NULL;
  c->sslContext = NULL;

  c->socket = tcpConnect ();
  if (c->socket)
    {
      // Register the error strings for libcrypto & libssl
      SSL_load_error_strings ();
      // Register the available ciphers and digests
      SSL_library_init ();

      // New context saying we are a client, and using SSL 2 or 3
      c->sslContext = SSL_CTX_new (SSLv23_client_method ());
      if (c->sslContext == NULL)
        ERR_print_errors_fp (stderr);

      // Create an SSL struct for the connection
      c->sslHandle = SSL_new (c->sslContext);
      if (c->sslHandle == NULL)
        ERR_print_errors_fp (stderr);

      // Connect the SSL struct to our connection
      if (!SSL_set_fd (c->sslHandle, c->socket))
        ERR_print_errors_fp (stderr);

      // Initiate SSL handshake
      if (SSL_connect (c->sslHandle) != 1)
        ERR_print_errors_fp (stderr);
    }
  else
    {
      perror ("Connect failed");
    }

  return c;
}

// Disconnect & free connection struct
void sslDisconnect (connection *c)
{
  if (c->socket)
    close (c->socket);
  if (c->sslHandle)
    {
      SSL_shutdown (c->sslHandle);
      SSL_free (c->sslHandle);
    }
  if (c->sslContext)
    SSL_CTX_free (c->sslContext);

  free (c);
}

// Read all available text from the connection
char *sslRead (connection *c)
{
  const int readSize = 2048;
  char *rc = NULL;
  int received, count = 0;
  char buffer[2048];

  if (c)
    {
      while (1)
        {
          if (!rc)
            rc = malloc (readSize * sizeof (char) + 1);
          else
            rc = realloc (rc, (count + 1) *
                          readSize * sizeof (char) + 1);

          received = SSL_read (c->sslHandle, buffer, readSize);
          buffer[received] = '\0';

          if (received > 0)
            strcat (rc, buffer);

          if (received < readSize)
            break;
          count++;
        }
    }

  return rc;
}

// Write text to the connection
void sslWrite (connection *c, char *text)
{
  if (c)
    SSL_write (c->sslHandle, text, strlen (text)
}

// Very basic main: we send GET / and print the response.
int main (int argc, char **argv)
{
  connection *c;
  char *response;
  char request[512]="";

  c = sslConnect ();

  sprintf(request, "GET https://%s%s%s\r\n\r\n", SERVER, KEY, argv[1]);
  printf("%s", request);

  sslWrite (c, request);

  response = sslRead (c);

  printf ("%s\n", response);

  sslDisconnect (c);
  free (response);

  return 0;
}

#包括sys/socket.h
#包括sys/types.h
#包括netinet/in.h
#包括netdb.h
#包括stdio.h
#包括string.h
#包括stdlib.h
#包括unistd.h
#包括errno.h
#包括openssl/rand.h
#包括openssl/ssl.h
#包括openssl/err.h
//结构简单，可跟踪把手，以及
//以后需要释放的内容。
类型定义结构{
int插座；
SSL*sslHandle；
SSL_CTX*sslContext；
}联系；
//对于这个例子，我们将在openssl.org上进行测试
#定义键“/customsearch/v1？键=AIzaSyAOdB5MgAEmvzglw05rR1OPYEYgFuZrT9o&cx=003397780648636422832:u25rx3s92ro&q=”
#定义服务器“www.googleapis.com”
#定义端口443
//建立常规tcp连接
int tcpConnect（）
{
int错误，句柄；
结构主机*主机；
服务器中的结构sockaddr_；
主机=gethostbyname（服务器）；
handle=socket（AF\u INET，SOCK\u STREAM，0）；
如果（句柄==-1）
{
佩罗（“插座”）；
句柄=0；
}
其他的
{
server.sinu family=AF\u INET；
server.sin_port=htons（端口）；
server.sin\u addr=*（（struct in\u addr*）host->h\u addr）；
bzero（&（server.sin_zero），8）；
错误=连接（句柄，（结构sockaddr*）和服务器，
sizeof（struct sockaddr））；
如果（错误==-1）
{
perror（“连接”）；
句柄=0；
}
}
返回手柄；
}
//使用SSL层建立连接
连接*SSL连接（无效）
{
连接*c；
c=malloc（sizeof（连接））；
c->sslHandle=NULL；
c->sslContext=NULL；
c->socket=tcpConnect（）；
if（c->socket）
{
//注册libcrypto和libssl的错误字符串
SSL_加载_错误_字符串（）；
//注册可用的密码和摘要
SSL_库_init（）；
//新上下文表明我们是一个客户机，并使用SSL 2或3
c->sslContext=SSL\u CTX\u new（SSLv23\u client\u method（））；
如果（c->sslContext==NULL）
错误打印错误fp（stderr）；
//为连接创建SSL结构
c->sslHandle=SSL\u新建（c->sslContext）；
如果（c->sslHandle==NULL）
错误打印错误fp（stderr）；
//将SSL结构连接到我们的连接
如果（！SSL\u set\u fd（c->sslHandle，c->socket））
错误打印错误fp（stderr）；
//启动SSL握手
如果（SSL\U连接（c->sslHandle）！=1）
错误打印错误fp（stderr）；
}
其他的
{
perror（“连接失败”）；
}
返回c；
}
//断开连接和释放连接结构
无效sslDisconnect（连接*c）
{
if（c->socket）
关闭（c->插座）；
如果（c->sslHandle）
{
SSL\u关闭（c->sslHandle）；
无SSL（c->sslHandle）；
}
如果（c->sslContext）
无SSL（c->sslContext）；
免费（c）；
}
//读取连接中的所有可用文本
字符*sslRead（连接*c）
{
常数int readSize=2048；
char*rc=NULL；
接收到int，计数=0；
字符缓冲区[2048]；
如果（c）
{
而(1)
{
如果（！rc）
rc=malloc（readSize*sizeof（char）+1）；
其他的
rc=realloc（rc，（计数+1）*
readSize*sizeof（char）+1）；
已接收=SSL\U读取（c->sslHandle，buffer，readSize）；
缓冲区[接收]='\0'；
如果（收到>0）
strcat（rc，缓冲器）；
如果（接收<读取大小）
打破
计数++；
}
}
返回rc；
}
//向连接写入文本
void sslWrite（连接*c，字符*text）
{
如果（c）
SSL_写入（c->sslHandle，text，strlen（text）
}
//非常基本的main：我们发送GET/并打印响应。
int main（int argc，字符**argv）
{
连接*c；
字符*响应；
字符请求[512]=“”；
c=sslConnect（）；
sprintf（请求，“获取https://%s%s%s\r\n\r\n”，服务器，密钥，argv[1]）；
printf（“%s”，请求）；
sslWrite（c，请求）；
响应=sslRead（c）；
printf（“%s\n”，响应）；
sslDisconnect（c）；
自由（反应）；
返回0；
}

以下是我的结果（运行“应用程序名称”）：

¸hÆÁ*HTTP/1.0 200 OK

过期时间：2012年5月23日星期三05:49:58 GMT

日期：2012年5月23日星期三05:49:58 GMT

缓存控制：私有，最大年龄=0，必须重新验证，无转换

ETag：“ewDGMApuuzSJ2mUepyXm8PLTiIU/UPD2CBC0DJAL0Y0Y6HIAVZSQST”

内容类型：application/json；字符集=UTF-8

X-Content-Type-Options:nosniff

X-Frame-Options:SAMEORIGIN

X-XSS-保护：1；模式=块

伺服器：GSE

---

---

肯定有更多关于炉子的信息，对吗？

上述代码中的两个问题是#1）在

malloc

之后和使用

strcat

之前，

rc

的开头没有初始化为零，这会导致垃圾字符，以及#2）行

if（接收

应该是

如果（received==0）

，因为服务器可能会将标题和内容作为单独的块发送

为什么要编写自己的HTTP接口，而不是使用类似的东西？看起来在缓冲区前面有一些垃圾。在没有看到您的代码的情况下，这里的任何人都猜不到您的问题所在。@JoachimPileborg-我计划在这个原型工作后使用libcurl。我正在学习如何与web客户机交互，并希望从尽可能低的级别开始。@Mat-我注意到了这一点，但它显然不会干扰我获得的标题数据。我添加了我的代码。谢谢