void DNSResolver::interactive(string input, vector<string> dns_servers)

      {

              char buffer[512];
              SOCKET sock;

              sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

              if (sock == INVALID_SOCKET)

              {

                      printf ("socket() generated error %d\n", WSAGetLastError());

                      WSACleanup ();

                      return;

              }



              struct sockaddr_in destination;



              destination.sin_family = AF_INET;

              destination.sin_port = htons(53);

              destination.sin_addr.s_addr = inet_addr(dns_servers[0].c_str());

              fixedDNSheader* dns = (fixedDNSheader*) &buffer;

              dns->ID = htons(sock);

              dns->flags = htons(DNS_QUERY | DNS_RD);

              dns->opcode = 0;

              dns->authoritiveAnswer = 0;

              dns->truncated = 0;

              dns->recursionDesired = 0;
              dns->recursionAvailable = 0;
              dns->zBit = 0;
              dns->authenticatedData = 0;
                dns->checkingDisabled = 0;
                dns->responseCode = 0;
              dns->numQuestions = htons(1); // One question
              dns->numAnswer = 0;
              dns->numAutorityAnswers = 0;
              dns->numAdditional = 0;

              char* queryName = (char*)&buffer[sizeof(fixedDNSheader)];

             // queryHeader* QH = (queryHeader*) (buffer + 512 - sizeof(queryName));
                queryHeader* QH = (queryHeader*)&buffer[sizeof(fixedDNSheader) + sizeof(queryName) + 1];

              if (newParser.validateIpAddress(input) == true)

              {
                      string reverseIP = newParser.reverseStr(input);
                      reverseIP.append(".in-addr.arpa");
                      makeDNSquestion(queryName +1, reverseIP);
                      QH->type = DNS_PTR;
                      QH->queryClass = htons(1);
              }
              else
              {
                      makeDNSquestion(queryName + 1, input);
                      QH->type = DNS_A;
                      QH->queryClass = htons(1);
              }



              struct sockaddr_in listen;



              listen.sin_family = AF_INET;

              listen.sin_addr.S_un.S_addr = INADDR_ANY;

              listen.sin_port = 0;



              if (bind(sock, (SOCKADDR*) &listen, sizeof(listen)) == SOCKET_ERROR)

              {

                      printf("bind() failed.\n");

                      closesocket(sock);

                      return;

              }


              int count = 0;

              while (count++ < 3)

              {

                      printf("Sending Packet...\n");

                      if (sendto(sock, (char*)buffer, sizeof(fixedDNSheader) + (strlen((const char*) queryName) + 1) +

                              sizeof(QH), 0, (struct sockaddr*)&destination, sizeof(destination)) == SOCKET_ERROR)

                      {

                              printf("%d error", WSAGetLastError());

                      }

                      printf("Sent\n");



                      timeval timeout;

                      timeout.tv_sec = 15;

                      timeout.tv_usec = 0;



                      fd_set fd;

                      FD_ZERO (&fd);

                      FD_SET (sock, &fd);

                      int available = select(0, &fd, NULL, NULL, &timeout);
                      if (available > 0)

                      {
                              int i = sizeof(destination);
                              printf("Receiving answer...\n");
                              if(recvfrom (sock, (char*)buffer, 512, 0, (struct sockaddr*)&destination, &i) == SOCKET_ERROR)
                              {
                                      printf("Failed. Error Code : %d",WSAGetLastError());
                              }
                              printf("Received.");
                              break;

                 }

              }