本文整理汇总了C++中channel_new函数的典型用法代码示例。如果您正苦于以下问题:C++ channel_new函数的具体用法?C++ channel_new怎么用?C++ channel_new使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了channel_new函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: server_request_tun
static Channel *
server_request_tun(void)
{
Channel *c = NULL;
int mode, tun;
int sock;
mode = packet_get_int();
switch (mode) {
case SSH_TUNMODE_POINTOPOINT:
case SSH_TUNMODE_ETHERNET:
break;
default:
packet_send_debug("Unsupported tunnel device mode.");
return NULL;
}
if ((options.permit_tun & mode) == 0) {
packet_send_debug("Server has rejected tunnel device "
"forwarding");
return NULL;
}
tun = packet_get_int();
if (forced_tun_device != -1) {
if (tun != SSH_TUNID_ANY && forced_tun_device != tun)
goto done;
tun = forced_tun_device;
}
sock = tun_open(tun, mode);
if (sock < 0)
goto done;
if (options.hpn_disabled)
c = channel_new("tun", SSH_CHANNEL_OPEN, sock, sock, -1,
CHAN_TCP_WINDOW_DEFAULT, CHAN_TCP_PACKET_DEFAULT, 0,
"tun", 1);
else
c = channel_new("tun", SSH_CHANNEL_OPEN, sock, sock, -1,
options.hpn_buffer_size, CHAN_TCP_PACKET_DEFAULT, 0,
"tun", 1);
c->datagram = 1;
#if defined(SSH_TUN_FILTER)
if (mode == SSH_TUNMODE_POINTOPOINT)
channel_register_filter(c->self, sys_tun_infilter,
sys_tun_outfilter, NULL, NULL);
#endif
done:
if (c == NULL)
packet_send_debug("Failed to open the tunnel device.");
return c;
}
示例2: server_request_session
static Channel *
server_request_session(struct ssh *ssh)
{
Channel *c;
int r;
debug("input_session_request");
if ((r = sshpkt_get_end(ssh)) != 0)
fatal("%s: %s", __func__, ssh_err(r));
if (no_more_sessions) {
ssh_packet_disconnect(ssh,
"Possible attack: attempt to open a session "
"after additional sessions disabled");
}
/*
* A server session has no fd to read or write until a
* CHANNEL_REQUEST for a shell is made, so we set the type to
* SSH_CHANNEL_LARVAL. Additionally, a callback for handling all
* CHANNEL_REQUEST messages is registered.
*/
c = channel_new(ssh, "session", SSH_CHANNEL_LARVAL,
-1, -1, -1, /*window size*/0, CHAN_SES_PACKET_DEFAULT,
0, "server-session", 1);
if (session_open(ssh, c->self) != 1) {
debug("session open failed, free channel %d", c->self);
channel_free(c);
return NULL;
}
channel_register_cleanup(c->self, session_close_by_channel, 0);
return c;
}
示例3: spice_gtk_session_constructor
static GObject *
spice_gtk_session_constructor(GType gtype,
guint n_properties,
GObjectConstructParam *properties)
{
GObject *obj;
SpiceGtkSession *self;
SpiceGtkSessionPrivate *s;
GList *list;
GList *it;
{
/* Always chain up to the parent constructor */
GObjectClass *parent_class;
parent_class = G_OBJECT_CLASS(spice_gtk_session_parent_class);
obj = parent_class->constructor(gtype, n_properties, properties);
}
self = SPICE_GTK_SESSION(obj);
s = self->priv;
if (!s->session)
g_error("SpiceGtKSession constructed without a session");
g_signal_connect(s->session, "channel-new",
G_CALLBACK(channel_new), self);
g_signal_connect(s->session, "channel-destroy",
G_CALLBACK(channel_destroy), self);
list = spice_session_get_channels(s->session);
for (it = g_list_first(list); it != NULL; it = g_list_next(it)) {
channel_new(s->session, it->data, (gpointer*)self);
}
g_list_free(list);
return obj;
}
示例4: shell
void shell(SSH_SESSION *session){
CHANNEL *channel;
struct termios terminal_local;
int interactive=isatty(0);
channel = channel_new(session);
if(interactive){
tcgetattr(0,&terminal_local);
memcpy(&terminal,&terminal_local,sizeof(struct termios));
}
if(channel_open_session(channel)){
printf("error opening channel : %s\n",ssh_get_error(session));
return;
}
chan=channel;
if(interactive){
channel_request_pty(channel);
sizechanged();
}
if(channel_request_shell(channel)){
printf("Requesting shell : %s\n",ssh_get_error(session));
return;
}
if(interactive){
cfmakeraw(&terminal_local);
tcsetattr(0,TCSANOW,&terminal_local);
setsignal();
}
signal(SIGTERM,do_cleanup);
select_loop(session,channel);
}
示例5: g_object_new
/**
* spice_display_new:
* @session: a #SpiceSession
* @id: the display channel ID to associate with #SpiceDisplay
*
* Returns: a new #SpiceDisplay widget.
**/
SpiceDisplay *spice_display_new(SpiceSession *session, int id)
{
SpiceDisplay *display;
SpiceDisplayPrivate *d;
GList *list;
GList *it;
display = g_object_new(SPICE_TYPE_DISPLAY, NULL);
d = SPICE_DISPLAY_GET_PRIVATE(display);
d->session = g_object_ref(session);
d->channel_id = id;
SPICE_DEBUG("channel_id:%d",d->channel_id);
g_signal_connect(session, "channel-new",
G_CALLBACK(channel_new), display);
g_signal_connect(session, "channel-destroy",
G_CALLBACK(channel_destroy), display);
list = spice_session_get_channels(session);
for (it = g_list_first(list); it != NULL; it = g_list_next(it)) {
channel_new(session, it->data, (gpointer*)display);
}
g_list_free(list);
return display;
}
示例6: server_request_direct_tcpip
static Channel *
server_request_direct_tcpip(char *ctype)
{
Channel *c;
int sock;
char *target, *originator;
int target_port, originator_port;
target = packet_get_string(NULL);
target_port = packet_get_int();
originator = packet_get_string(NULL);
originator_port = packet_get_int();
packet_check_eom();
debug("server_request_direct_tcpip: originator %s port %d, target %s port %d",
originator, originator_port, target, target_port);
/* XXX check permission */
sock = channel_connect_to(target, target_port);
xfree(target);
xfree(originator);
if (sock < 0)
return NULL;
c = channel_new(ctype, SSH_CHANNEL_CONNECTING,
sock, sock, -1, CHAN_TCP_WINDOW_DEFAULT,
CHAN_TCP_PACKET_DEFAULT, 0, "direct-tcpip", 1);
return c;
}
示例7: server_request_session
static Channel *
server_request_session(void)
{
Channel *c;
debug("input_session_request");
packet_check_eom();
if (no_more_sessions) {
packet_disconnect("Possible attack: attempt to open a session "
"after additional sessions disabled");
}
/*
* A server session has no fd to read or write until a
* CHANNEL_REQUEST for a shell is made, so we set the type to
* SSH_CHANNEL_LARVAL. Additionally, a callback for handling all
* CHANNEL_REQUEST messages is registered.
*/
c = channel_new("session", SSH_CHANNEL_LARVAL,
-1, -1, -1, /*window size*/0, CHAN_SES_PACKET_DEFAULT,
0, "server-session", 1);
if (session_open(the_authctxt, c->self) != 1) {
debug("session open failed, free channel %d", c->self);
channel_free(c);
return NULL;
}
channel_register_cleanup(c->self, session_close_by_channel, 0);
return c;
}
示例8: channel_dup
static channel_t * channel_dup(channel_t *chan){
channel_t *chand = channel_new(chan->fun,chan->channel,chan->f_param_count);
fun_t ** f_param = chand->f_param;
memcpy(chand,chan,sizeof(channel_t));
chand->f_param = f_param;
memcpy(chand->f_param,chan->f_param,chan->f_param_count*sizeof(fun_t**));
return chand;
}
示例9: log_error
tcp_connection_t* tcp_connection_new
(
loop_t *loop, int fd, on_data_f datacb, on_close_f closecb, void* userdata, const inetaddr_t *peer_addr
)
{
tcp_connection_t *connection;
struct sockaddr_in addr;
socklen_t addr_len;
struct linger linger_info;
int flag;
if (NULL == loop || fd < 0 || NULL == datacb || NULL == closecb || NULL == peer_addr)
{
log_error("tcp_connection_new: bad loop(%p) or bad fd(%d) or bad datacb(%p) or bad closecb(%p) or bad peer_addr(%p)",
loop, fd, datacb, closecb, peer_addr);
return NULL;
}
connection = (tcp_connection_t*)malloc(sizeof(*connection));
memset(connection, 0, sizeof(*connection));
flag = 1;
setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &flag, sizeof(flag));
memset(&linger_info, 0, sizeof(linger_info));
linger_info.l_onoff = 1;
linger_info.l_linger = 3;
setsockopt(fd, SOL_SOCKET, SO_LINGER, &linger_info, sizeof(linger_info));
connection->loop = loop;
connection->fd = fd;
connection->datacb = datacb;
connection->closecb = closecb;
connection->userdata = userdata;
connection->channel = channel_new(fd, loop, connection_onevent, connection);
connection->in_buffer = buffer_new(4096);
connection->out_buffer = buffer_new(4096);
connection->is_in_callback = 0;
connection->is_alive = 1;
connection->is_connected = 1;
connection->need_closed_after_sent_done = 0;
connection->peer_addr = *peer_addr;
memset(&addr, 0, sizeof(addr));
addr_len = sizeof(addr);
getsockname(fd, (struct sockaddr*)&addr, &addr_len);
inetaddr_init(&connection->local_addr, &addr);
channel_setevent(connection->channel, EPOLLIN);
return connection;
}
示例10: eventloop_on_out_fd
/** Create a new Channel with the specified callbacks to manage outgoing data.
*
* \param name name of this object, used for debugging
* \param fd file descriptor to consider
* \param status_cbk callback function called when the state of the socket changes, can be NULL
* \param handle pointer to opaque data passed to callback functions
* \return a pointer to the new Channel
*
* \see o_el_state_socket_callback
* \see channel_new
*/
static Channel* eventloop_on_out_fd(
char* name,
int fd,
o_el_state_socket_callback status_cbk,
void* handle
) {
Channel* ch = channel_new(name, fd, POLLOUT, status_cbk, handle);
return ch;
}
示例11: forwarding
static void forwarding(ssh_session session){
ssh_channel channel;
int r;
channel=channel_new(session);
r=channel_open_forward(channel,desthost,atoi(port),"localhost",22);
if(r<0) {
printf("error forwarding port : %s\n",ssh_get_error(session));
return;
}
select_loop(session,channel);
}
示例12: batch_shell
void batch_shell(SSH_SESSION *session){
CHANNEL *channel;
char buffer[1024];
int i,s=0;
for(i=0;i<MAXCMD && cmds[i];++i)
s+=snprintf(buffer+s,sizeof(buffer)-s,"%s ",cmds[i]);
channel=channel_new(session);
channel_open_session(channel);
if(channel_request_exec(channel,buffer)){
printf("error executing \"%s\" : %s\n",buffer,ssh_get_error(session));
return;
}
select_loop(session,channel);
}
示例13: eventloop_on_in_fd
/** Create a new Channel with the specified callbacks on incoming data.
*
* \param name name of this object, used for debugging
* \param fd file descriptor to consider
* \param read_cbk callback function called when there is data to read, can be NULL
* \param monitor_cbk callback function called when a new normal event arrives but no read_cbk was registered (e.g., listening socket), can be NULL
* \param status_cbk callback function called when the state of the socket changes, can be NULL
* \param handle pointer to opaque data passed to callback functions
* \return a pointer to the new Channel
*
* \see o_el_read_socket_callback, o_el_monitor_socket_callback, o_el_state_socket_callback
* \see channel_new
*/
static Channel* eventloop_on_in_fd(
char* name,
int fd,
o_el_read_socket_callback read_cbk,
o_el_monitor_socket_callback monitor_cbk,
o_el_state_socket_callback status_cbk,
void* handle
) {
Channel* ch = channel_new(name, fd, POLLIN, status_cbk, handle);
ch->read_cbk = read_cbk;
ch->monitor_cbk = monitor_cbk;
/* status_cbk is already set by channel_new */
return ch;
}
示例14: client_pipe
// Connect to a SSH server.
// When the connection is established, read data from stdin and send it to the server.
void client_pipe(char *host, int port)
{
ssh_session s = ssh_new();
ssh_options_set(s, SSH_OPTIONS_HOST, host);
ssh_options_set(s, SSH_OPTIONS_PORT, &port);
ssh_options_set(s, SSH_OPTIONS_USER, "xya");
//ssh_options_set(s, SSH_OPTIONS_LOG_VERBOSITY_STR, "5");
if(ssh_connect(s) != SSH_OK)
return session_error(s, "connect");
char *hash = pubkey_hash(ssh_get_pubkey(s));
if(authenticate(hash, 0))
{
session_event(s, "authenticated", hash);
free(hash);
}
else
{
free(hash);
exit(1);
}
int keytype;
ssh_string pub = publickey_from_file(s, "test-client-key.pub", &keytype);
if(!pub)
session_error(s, "open-public-key");
if(SSH_AUTH_SUCCESS != ssh_userauth_offer_pubkey(s, NULL, keytype, pub))
session_error(s, "offer-public-key");
ssh_private_key priv = privatekey_from_file(s, "test-client-key", keytype, NULL);
if(!priv)
session_error(s, "open-private-key");
if(SSH_AUTH_SUCCESS != ssh_userauth_pubkey(s, NULL, pub, priv))
session_error(s, "user-auth");
string_free(pub);
privatekey_free(priv);
ssh_channel chan = channel_new(s);
if(!chan)
session_error(s, "create-channel");
if(channel_open_session(chan) < 0)
session_error(s, "open-channel");
session_event(s, "channel-opened", NULL);
channel_from_file(chan, 0);
channel_free(chan);
ssh_disconnect(s);
ssh_finalize();
}
示例15: ssh_scp_init
int ssh_scp_init(ssh_scp scp){
int r;
char execbuffer[1024];
uint8_t code;
if(scp->state != SSH_SCP_NEW){
ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_init called under invalid state");
return SSH_ERROR;
}
ssh_log(scp->session,SSH_LOG_PROTOCOL,"Initializing scp session %s %son location '%s'",
scp->mode==SSH_SCP_WRITE?"write":"read",
scp->recursive?"recursive ":"",
scp->location);
scp->channel=channel_new(scp->session);
if(scp->channel == NULL){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
r= channel_open_session(scp->channel);
if(r==SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
if(scp->mode == SSH_SCP_WRITE)
snprintf(execbuffer,sizeof(execbuffer),"scp -t %s %s",
scp->recursive ? "-r":"", scp->location);
else
snprintf(execbuffer,sizeof(execbuffer),"scp -f %s %s",
scp->recursive ? "-r":"", scp->location);
if(channel_request_exec(scp->channel,execbuffer) == SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
if(scp->mode == SSH_SCP_WRITE){
r=channel_read(scp->channel,&code,1,0);
if(code != 0){
ssh_set_error(scp->session,SSH_FATAL, "scp status code %ud not valid", code);
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
} else {
channel_write(scp->channel,"",1);
}
if(scp->mode == SSH_SCP_WRITE)
scp->state=SSH_SCP_WRITE_INITED;
else
scp->state=SSH_SCP_READ_INITED;
return SSH_OK;
}