Logo Search packages:      
Sourcecode: pacemaker-mgmt version File versions  Download package

mgmt_client_lib.c

/*
 * Client-side Linux HA management library
 *
 * Author: Huang Zhen <zhenhltc@cn.ibm.com>
 * Copyright (C) 2005 International Business Machines
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include <pygui_internal.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdarg.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <mgmt/mgmt_tls.h>
#include <mgmt/mgmt_client.h>

#define ISCONNECTED()   (session)


int         sock = 0;
void*       session = NULL;
/*
 *    return value
 *    -1:can't connect to server
 *    -2:auth failed
 *    -3:protocol version mismatch
 *    0 :success
 */
int
mgmt_connect(const char* server, const char* user
,           const char*  passwd, const char* port)
{
      struct sockaddr_in addr;
      char* msg;
      char* ret;
      int rv;
      
      /* if it has already connected, return fail */
      if (ISCONNECTED()) {
            return -1;
      }

      /* create socket */
      sock=socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
      if (sock == -1 ) {
            return -1;
      }

      /* connect to server*/
      memset(&addr, 0, sizeof(addr));
      addr.sin_family = AF_INET;
      addr.sin_addr.s_addr = inet_addr(server);
      if (port == NULL || STRNCMP_CONST(port,"None")) {
            addr.sin_port = htons(PORT);
      }
      else {
            addr.sin_port = htons(atoi(port));
      }
      if (connect(sock, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
            close(sock);
            return -1;
      }

      /* initialize GnuTls lib*/
      if (tls_init_client() == -1) {
            return -1;
      }

      /* bind the socket to GnuTls lib */
      session = tls_attach_client(sock);
      if (session == NULL) {
            close(sock);
            tls_close_client();
            return -1;
      }

      /* login to server */
      msg = mgmt_new_msg(MSG_LOGIN, user, passwd, MGMT_PROTOCOL_VERSION, NULL);
      ret = mgmt_sendmsg(msg);
      if (ret == NULL) {
            rv = -1;
      }
      else if (STRNCMP_CONST(ret,MSG_OK) == 0) {
            rv = 0;
      }
      else if (STRNCMP_CONST(ret,MSG_FAIL) == 0){
            rv = -2;
      }
      else {
            rv = -3;
      }
      
      mgmt_del_msg(msg);
      mgmt_del_msg(ret);
      if (rv != 0) {
            close(sock);
            tls_close_client();
      }
      return rv;
}

char* 
mgmt_sendmsg(const char* msg)
{
      /* send the msg */
      if (mgmt_session_sendmsg(session, msg) < 0) {
            return NULL;
      }
      /* get the result msg */
      return mgmt_session_recvmsg(session);
}

char*
mgmt_recvmsg(void)
{
      return mgmt_session_recvmsg(session);
}

int
mgmt_inputfd(void)
{
      if (!ISCONNECTED()) {
            return -1;
      }
      return sock;
}


int
mgmt_disconnect(void)
{
      if (!ISCONNECTED()) {
            return -1;
      }
      
      if (session != NULL) {
            mgmt_session_sendmsg(session, MSG_LOGOUT);
            tls_detach(session);
            session = NULL;
      }
      if (sock != 0) {
            close(sock);
            sock = 0;
      }
      tls_close_client();
      return 0;
}

int 
mgmt_session_sendmsg(void* session, const char* msg)
{
      int len, ret, count = 0;
      if (session == NULL) {
            return -1;
      }
      /* send the msg, with the last zero */
      /*len = strnlen(msg, MAX_MSGLEN)+1;
      if (len == MAX_MSGLEN + 1) {
            return -2;
      }*/
      len = strlen(msg) + 1;
      while (count < len) {
            ret = tls_send(session, msg + count, len - count) ;
            if (ret < 0) {
                  return -1;
            }
            else {
                  count += ret;
            }
      }
      /* get the bytes sent */
      return len;
}

char*
mgmt_session_recvmsg(void* session)
{
      char c;
      int cur = 0;
      int len = 0;
      char* buf = NULL;
      if (session == NULL) {
            return NULL;
      }

      while(1) {
            int rd = tls_recv(session, &c, 1);
            if (rd <= 0 && buf == NULL) {
                  /* no msg or something wrong */
                  return NULL;
            }
            if (rd == 1) {
                  /* read one char */
                  if (buf == NULL) {
                        /* malloc buf */
                        buf = (char*)mgmt_malloc(INIT_SIZE);
                        len = INIT_SIZE;
                  }
                  if (buf == NULL) {
                        return NULL;
                  }
                  /* the buf is full, enlarge it */
                  if (cur == len) {
                        buf = mgmt_realloc(buf, len+INC_SIZE);
                        if (buf == NULL) {
                              return NULL;
                        }
                        len += INC_SIZE;
                  }
                  
                  buf[cur] = c;
                  cur++;
                  if (c == 0) {
                        return buf;
                  }
            }
            /* something wrong */
            if (rd <= 0) {
                  if(errno == EINTR) {
                        continue;
                  }
                  mgmt_free(buf);
                  return NULL;
            }
      }
}


Generated by  Doxygen 1.6.0   Back to index