示例#1
0
bool Camera_INDIClass::Connect(const wxString& camId)
{
    // If not configured open the setup dialog
    if (strcmp(INDICameraName,"INDI Camera")==0) CameraSetup();
    // define server to connect to.
    setServer(INDIhost.mb_str(wxConvUTF8), INDIport);
    // Receive messages only for our camera.
    watchDevice(INDICameraName.mb_str(wxConvUTF8));
    // Connect to server.
    if (connectServer()) {
        return !ready;
    }
    else {
        // last chance to fix the setup
        CameraSetup();
        setServer(INDIhost.mb_str(wxConvUTF8), INDIport);
        watchDevice(INDICameraName.mb_str(wxConvUTF8));
        if (connectServer()) {
            return !ready;
        }
        else {
            return true;
        }
    }
}
示例#2
0
bool ScopeINDI::Connect()
{
    // If not configured open the setup dialog
    if (INDIMountName == wxT("INDI Mount")) {
        SetupDialog();
    }
    // define server to connect to.
    setServer(INDIhost.mb_str(wxConvUTF8), INDIport);
    // Receive messages only for our mount.
    watchDevice(INDIMountName.mb_str(wxConvUTF8));
    // Connect to server.
    if (connectServer()) {
        return !ready;
    }
    else {
        // last chance to fix the setup
        SetupDialog();
        setServer(INDIhost.mb_str(wxConvUTF8), INDIport);
        watchDevice(INDIMountName.mb_str(wxConvUTF8));
        if (connectServer()) {
            return !ready;
        }
        else {
            return true;
        }
    }
}
示例#3
0
void IOToaster::setup()
{
	// Set the pin configuration
	setupPins();

	// Open serial communication
	Serial.begin(9600);
	Serial.setTimeout(5000);	

	// Load the configuration
	if (isConfigured())
	{
		// Normal mode
		_setupMode = false;
		loadConfiguration();	
		connectServer();
		setActivityLedState(HIGH);		
	}
		
	else {
		// Setup mode
		setActivityLedState(LOW);
		_setupMode = true;		
		createServer();
	}
}
示例#4
0
文件: LogSender.cpp 项目: dmsTest/dms
void SocketSender::sendLog(std::list<MLogRec> &logs) throw(SendException)
{
	readFailFile(logs);
	connectServer();
	sendData(logs);
	saveFailFile(logs);
}
示例#5
0
int main(void)
{
	//Diccionario de funciones de comunicacion
	fns = dictionary_create();
	dictionary_put(fns, "server_saludar", &server_saludar);

	//Creo estrucutra de datos para esta conexion
	data_client * data = malloc(sizeof(data_client));
	data->x = 2;
	data->y = 9;

	//Me conecto a servidor, si hay error informo y finalizo
	if((socket_server = connectServer(ip, port, fns, &server_connectionClosed, data)) == -1)
	{
		printf("Error al intentar conectar a servidor. IP = %s, Puerto = %d.\n", ip, port);
		exit(1);
	}
	printf("Se ha conectado exitosamente a servidor. Socket = %d, IP = %s, Puerto = %d.\n", socket_server, ip, port);

	//saludo a servidor
	runFunction(socket_server, "client_saludar", 3, "hola", "como", "estas");

	//Dejo bloqueado main
	pthread_mutex_init(&mx_main, NULL);
	pthread_mutex_lock(&mx_main);
	pthread_mutex_lock(&mx_main);

	return EXIT_SUCCESS;
}
int CSocketClient::start(int nSocketType, const char* cszAddr, short nPort,
		int nStyle)
{
	if (AF_UNIX == nSocketType)
	{
		setDomainSocketPath(cszAddr);
	}
	else if (AF_INET == nSocketType)
	{
		if (-1 == setInetSocket(cszAddr, nPort))
		{
			_DBG("set INET socket address & port fail");
			return -1;
		}
	}

	if (-1 != createSocket(nSocketType, nStyle))
	{
		if (SOCK_STREAM == nStyle)
		{
			if (-1 == connectServer())
			{
				socketClose();
				return -1;
			}
		}

		_DBG("[Socket Client] Socket connect success");
		return getSocketfd();
	}

	return -1;
}
示例#7
0
/*
 * ftpc program sends the target file
 * to the server specified by the user
 * with ip address and port number.
 */
int main(int argc, char *argv[]) {
	int sockfd = -1;

	// precheck arguments
	if(preCheckArgs(argc, argv) == -1) {
		exit(-1);
	}

	// create the socket
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(sockfd < 0) {
		fprintf(stderr, "ftpc: ERROR: Can't create the socket.\n");
		exit(-1);
	}

	// connect to the server
	if(connectServer(sockfd, /*ip address*/argv[1], /*port*/argv[2]) < 0) {
		exit(-1);
	}

	// send the file to the server
	sendFileToServer(sockfd, argv[3]);

	return 0;
}
int ESP8266_XYZ::httpGet(const char* server, String path, int port, String *response){
	String msg = "";
	String server_str = server;

	if(connectServer(server, port)){
		#ifdef DEBUG 
			Serial.println("Connected to server");
		#endif

	} else {
		#ifdef DEBUG
			Serial.println("Connection Failure");
		#endif
	}

	server_str += ":";
	server_str += String(port);

	//GET  HTTP/1.1\r\nHost: \r\n\r\n
	//Solicitud HTTP al servidor
	//Header
    msg += "GET ";
    msg += path;
    msg += " HTTP/1.1\r\nHost: ";
   	msg += server_str;
	msg += "\r\n\r\n";

	//Se envía el mensaje al servidor
	client.print(msg);

	//Se obtiene el código de estado de la solicitud
	return readResponse(response);
}
示例#9
0
void MainWindow::changeServerStatus(bool s)
{
    if(s)
        connectServer();
    else
        disconnectServer();
}
示例#10
0
int FClient::requestID(const char *desc)
{
	int socketfd;
	unsigned char buf[128];
	int i;
	unsigned int uret;
	FILE *f;
	int hid;

	hid = gethostid();

	/* connect to the server */
	socketfd = connectServer();
	if (socketfd<0) {
		return 0;
	}
	
	/* send the request */
	sendMessage(socketfd,"",FGETMACHINEID);

	/* read the id */
	uret = readU32(socketfd);

	/* close the socket */
	close(socketfd);

	return uret;
}
示例#11
0
int FClient::sendFile(const char *fname)
{
	int socketfd;
	unsigned char buf[128];
	int i;
	unsigned int hashval;
	FILE *f;

	/* connect to the server */
	socketfd = connectServer();
	if (socketfd<0) {
		return 0;
	}
	

	/* send the request */
	sendMessage(socketfd,fname,FSENDFILE);

	/* send the file */
	writeFile(fname,socketfd);


	/* close the socket */
	close(socketfd);

	return 1;
}
void RSocketServer::onRSocketSetup(
    std::shared_ptr<RSocketServiceHandler> serviceHandler,
    std::shared_ptr<ConnectionSet> connectionSet,
    bool scheduledResponder,
    std::unique_ptr<DuplexConnection> connection,
    SetupParameters setupParams) {
  const auto eventBase = folly::EventBaseManager::get()->getExistingEventBase();
  VLOG(2) << "Received new setup payload on " << eventBase->getName();
  CHECK(eventBase);
  auto result = serviceHandler->onNewSetup(setupParams);
  if (result.hasError()) {
    VLOG(3) << "Terminating SETUP attempt from client. "
            << result.error().what();
    connection->send(
        FrameSerializer::createFrameSerializer(setupParams.protocolVersion)
            ->serializeOut(Frame_ERROR::rejectedSetup(result.error().what())));
    return;
  }
  auto connectionParams = std::move(result.value());
  if (!connectionParams.responder) {
    LOG(ERROR) << "Received invalid Responder. Dropping connection";
    connection->send(
        FrameSerializer::createFrameSerializer(setupParams.protocolVersion)
            ->serializeOut(Frame_ERROR::rejectedSetup(
                "Received invalid Responder from server")));
    return;
  }
  const auto rs = std::make_shared<RSocketStateMachine>(
      scheduledResponder
          ? std::make_shared<ScheduledRSocketResponder>(
                std::move(connectionParams.responder), *eventBase)
          : std::move(connectionParams.responder),
      nullptr,
      RSocketMode::SERVER,
      connectionParams.stats,
      std::move(connectionParams.connectionEvents),
      setupParams.resumable
          ? std::make_shared<WarmResumeManager>(connectionParams.stats)
          : ResumeManager::makeEmpty(),
      nullptr /* coldResumeHandler */);

  if (!connectionSet->insert(rs, eventBase)) {
    VLOG(1) << "Server is closed, so ignore the connection";
    connection->send(
        FrameSerializer::createFrameSerializer(setupParams.protocolVersion)
            ->serializeOut(Frame_ERROR::rejectedSetup(
                "Server ignores the connection attempt")));
    return;
  }
  rs->registerCloseCallback(connectionSet.get());

  auto requester = std::make_shared<RSocketRequester>(rs, *eventBase);
  auto serverState = std::shared_ptr<RSocketServerState>(
      new RSocketServerState(*eventBase, rs, std::move(requester)));
  serviceHandler->onNewRSocketState(std::move(serverState), setupParams.token);
  rs->connectServer(
      std::make_shared<FrameTransportImpl>(std::move(connection)),
      std::move(setupParams));
}
// Initialize Networking Sockets
void initPeerSocket(void) {
	#ifdef SERVERMODE
	fdPeerSock = acceptClient();
	#endif

	#ifdef CLIENTMODE
	fdPeerSock = connectServer();
	#endif
}
示例#14
0
void initRemoteDebugging()
{
	WORD ver = MAKEWORD(1, 1);
	WSADATA data;
	WSAStartup(ver, &data);

	debugEventSocket = connectServer("127.0.0.1", 1523);
	if (debugEventSocket < 0)
		debugEventSocket = 0;
}
示例#15
0
bool SocketTest::init()
{
	if (!Layer::init())
	{
		return false;
	}

	connectServer();
	return true;
}
示例#16
0
void FClient::requestFileListRebuild()
{
	unsigned int socketfd;

	/* connect to the server */
	socketfd = connectServer();

	/* send the message */
	sendMessage(socketfd,"",FREQUESTDIRLISTING);
}
示例#17
0
void INDIConfig::Connect()
{
    dev->Clear();
    Disconnect();
    INDIhost = host->GetLineText(0);
    port->GetLineText(0).ToLong(&INDIport);
    setServer(INDIhost.mb_str(wxConvUTF8), INDIport);
    if (connectServer()) {
	connect_status->SetLabel(_T("Connected"));
    }
}
示例#18
0
void *
threadStart(void *arg)
{
    int server_fd = connectServer(server_info.address, server_info.port);
    if(server_fd == -1)
        pthread_exit((void *)-1);
    
    test(server_fd);
    close(server_fd);
    pthread_exit((void *)0);
}
示例#19
0
文件: test.c 项目: nickkpoon/CS176B2
int startDataSocket(int socket, char *msg)
{
    int sockdata = 0;
    int port = convertPortNo(msg);
    char ip[strlen(msg)];
    char *address;
    int i = 0, count = 0, n = 0;

    char recvBuff[1024];
    char filename[100]="fileName\n";

/*
 *
 * * * * * CONVERT PASV MESSAGE TO IP ADDRESS
 *
 */
    strcpy(ip, msg);

    while (ip[i] != '\0')
    {
        if (ip[i] == ',')
        {
            ip[i] = '.';
            count++;
        }
        if (count == 4)
        {
            ip[i] = '\0';
        }
        i++;
    }
    
    i = 0;
    count = 0;

    address = ip + 1;

    //printf("\n Creating Data Socket... \n");
    //printf("\n portno:%i", port);
    

    //printf("\n Connecting Data Socket To Server... \n");

    n = connectServer(socket, address, port);
    if (n < 0)
    {
        printf("%s\n", strerror(errno));
        exit(1);
    }    

    return n;
}
示例#20
0
int OSGScaleViewer::run()
{
    // 1. connect to server
    eq::ServerPtr server = new eq::Server();
    if( !connectServer( server ))
    {
        EQERROR << "Can't open server" << std::endl;
        return EXIT_FAILURE;
    }

    // 2. choose config
    eq::ConfigParams configParams;
    Config* config = static_cast<Config*>( server->chooseConfig( configParams));

    if( !config )
    {
        EQERROR << "No matching config on server" << std::endl;
        disconnectServer( server );
        return EXIT_FAILURE;
    }

    config->setInitData( _initData );
    if( !config->init( ))
    {
        server->releaseConfig( config );
        disconnectServer( server );
        return EXIT_FAILURE;
    }
    else if( config->getError( ))
        EQWARN << "Error during initialization: " << config->getError()
               << std::endl;

    // 4. run main loop
    while( config->isRunning( ))
    {
        config->startFrame();
        config->finishFrame();
    }
    config->finishAllFrames();

    // 5. exit config
    config->exit();

    // 6. cleanup and exit
    server->releaseConfig( config );
    if( !disconnectServer( server ))
        EQERROR << "Client::disconnectServer failed" << std::endl;

    server = 0;

    return EXIT_SUCCESS;
}
示例#21
0
bool TServerList::onRecv()
{
	// Grab the data from the socket and put it into our receive buffer.
	unsigned int size = 0;
	char* data = sock.getData(&size);
	if (size != 0)
		rBuffer.write(data, size);

	if (!main())
		connectServer();

	return true;
}
示例#22
0
Client::Client(const int argc, char** argv, const bool isResident)
    : _impl(new Client::Impl(isResident))
{
    if (!initLocal(argc, argv))
        LBTHROW(std::runtime_error("Can't init client"));

    _impl->server = new eq::Server;
    if (!connectServer(_impl->server))
    {
        exitLocal();
        LBTHROW(std::runtime_error("Can't open server"));
    }
}
示例#23
0
int TVUClient::recvPackage(int &flag)
{
	if(m_pChannel == NULL)
	{
		//连接服务器
		if(connectServer()<1)
           {
               flag = TVU_ERROR_SERVER_NOT_OPEN;
               return NULL;
           }
    }
    return m_pChannel->recvPackage(flag);
}
示例#24
0
文件: main.c 项目: poifra/ift2245_tp2
int
main (int argc, char *argv[argc + 1])
{

  initThreadRunning ();

  int32_t *theMotherOfAllRequests = malloc (sizeof (int32_t) * 5);
  if (theMotherOfAllRequests == NULL)
    {
      printf ("memory is kill\n");
      exit (-1);
    }

  theMotherOfAllRequests[0] = BEGIN;
  theMotherOfAllRequests[1] = num_resources;
  theMotherOfAllRequests[2] = num_clients;
  theMotherOfAllRequests[3] = -1;
  theMotherOfAllRequests[4] = -1;

  int begin_fd = connectServer ();
  if (send_request (0, 0, begin_fd, theMotherOfAllRequests) == -1)
    {
      printf ("The server said screw you\n");
      exit (-1);
    }

  shutdown (begin_fd, 0);
  close (begin_fd);

  client_thread client_threads[NUM_CLIENTS];

  for (unsigned int i = 0; i < num_clients; i++)
    {
      ct_init (&(client_threads[i]));
    }

  ct_wait_server ();

  // Affiche le journal.
  st_print_results (stdout, true);
  FILE *fp = fopen ("client_log", "w");
  if (fp == NULL)
    {
      fprintf (stderr, "Could not print log");
      return EXIT_FAILURE;
    }
  st_print_results (fp, false);
  fclose (fp);

  return EXIT_SUCCESS;
}
int ESP8266_XYZ::httpPost(const char* server, String path, int port, String *response){
	String msg = "";
	String server_str = server;
	if(connectServer(server, port)){
		#ifdef DEBUG 
			Serial.println("Connected to server");
		#endif

	} else {
		#ifdef DEBUG 
			Serial.println("Connection Failure");
		#endif
		return -1;
	}

	server_str += ":";
	server_str += String(port);

	//Cálculo de lengitud total del mensaje
	uint16_t json_len = json.length();

	json.setCharAt(json_len-1, '}');

	//POST  HTTP/1.1\r\nHost: \r\nConnection: close\r\nAccept: application/json\r\nContent-Type: application/json\r\nContent-Length:\r\n\r\n

	//Solicitud HTTP al servidor
	//Header
	msg += "POST ";
	msg += path;
	msg += " HTTP/1.1\r\nHost: ";
	msg += server_str;
	msg += "\r\nConnection: close\r\n";
	msg += "Accept: application/json\r\n";
	msg += "Content-Type: application/json\r\nContent-Length:";
	msg += json_len;
	msg += "\r\n\r\n";
	msg += json;

	#ifdef DEBUG 
			Serial.print("Request: ");
			Serial.println(msg);
	#endif
	
	client.print(msg);
	//Reestablece el JSON para el siguiente POST
	json = "{";

	return readResponse(response);
	
}
示例#26
0
bool createMessgaeQueue(const char *tag, msgHandlerCB *cb) {
    bool result = true;

    if (init()) {
        MessageHeader *header = NewAndAddMessageHeader(tag, cb);
        if (NULL != header) {
            connectServer(header->fd, header->tag);
            printf("Begin to create Message Header Tag = %s\n", tag);
        } else {
            result = false;
        }
    }

    return result;
}
示例#27
0
int TVUClient::sendPackage(TVUPackage* package)
{
    if(m_pChannel == NULL)
            {
                if(connectServer()<1)
                   {
                       //连接服务器
//                       if(connectServer()<1)
//                          {
                              flag = TVU_ERROR_SERVER_NOT_OPEN;
                              return flag;
//                          }
                    }
            }
        return m_pChannel->sendTcpPackage(package);
}
示例#28
0
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    this->connect(ui->connectButton, SIGNAL(clicked()), this, SLOT(connectServer()));
    this->connect(ui->startButton, SIGNAL(clicked()), this,SLOT(startTcpserver()));
    this->connect(ui->sendButton, SIGNAL(clicked()), this,SLOT(sendMessage()));

    ui->lineEdit->setEnabled(false);
    ui->sendButton->setEnabled(false);

    ui->textEdit->clear();
    ui->textEdit->append("Initialized...");
    isServer = 0;
}
示例#29
0
int8_t Adafruit_MQTT::connect() {
  // Connect to the server.
  if (!connectServer())
    return -1;

  // Construct and send connect packet.
  uint8_t len = connectPacket(buffer);
  if (!sendPacket(buffer, len))
    return -1;

  // Read connect response packet and verify it
  len = readPacket(buffer, 4, CONNECT_TIMEOUT_MS);
  if (len != 4)
    return -1;
  if ((buffer[0] != (MQTT_CTRL_CONNECTACK << 4)) || (buffer[1] != 2))
    return -1;
  if (buffer[3] != 0)
    return buffer[3];

  // Setup subscriptions once connected.
  for (uint8_t i=0; i<MAXSUBSCRIPTIONS; i++) {
    // Ignore subscriptions that aren't defined.
    if (subscriptions[i] == 0) continue;

    // Construct and send subscription packet.
    uint8_t len = subscribePacket(buffer, subscriptions[i]->topic, subscriptions[i]->qos);
    if (!sendPacket(buffer, len))
      return -1;

    // Check for SUBACK if using MQTT 3.1.1 or higher
    // TODO: The Server is permitted to start sending PUBLISH packets matching the
    // Subscription before the Server sends the SUBACK Packet.
    // if(MQTT_PROTOCOL_LEVEL > 3) {
    //   len = readPacket(buffer, 5, CONNECT_TIMEOUT_MS);
    //   DEBUG_PRINT(F("SUBACK:\t"));
    //   DEBUG_PRINTBUFFER(buffer, len);
    //   if ((len != 5) || (buffer[0] != (MQTT_CTRL_SUBACK << 4))) {
    //     return 6;  // failure to subscribe
    //   }
    // }

  }

  return 0;
}
示例#30
0
int CSocketClient::start(int nSocketType, const char* cszAddr, short nPort, int nStyle)
{
	if ( AF_UNIX == nSocketType )
	{
		setDomainSocketPath( cszAddr );
	}
	else if ( AF_INET == nSocketType )
	{
		if ( -1 == setInetSocket( cszAddr, nPort ) )
		{
			_DBG( "set INET socket address & port fail" );
			return -1;
		}
	}

	if ( -1 != createSocket( nSocketType, nStyle ) )
	{
		if ( SOCK_STREAM == nStyle )
		{
			if ( -1 == connectServer() )
			{
				socketClose();
				return -1;
			}
		}

		if ( -1 != externalEvent.m_nMsgId )
		{
			if ( -1 == initMessage( externalEvent.m_nMsgId ) )
			{
				throwException( "socket client create message id fail" );
			}
			else
			{
				threadHandler->createThread( threadMessageReceive, this );
				threadHandler->createThread( threadSocketRecvHandler, this );
			}
		}

		_DBG( "[Socket Client] Socket connect success, FD:%d", getSocketfd() );
		return getSocketfd();
	}

	return -1;
}