LONG File::Write(CPCCHAR cpcBuffer, LONG lBufferSize, LONG lWriteSize)
{
LONG lResult = -1;
CHECK_RETURN_CODE(m_hFile, -1);
CHECK_RETURN_CODE(lBufferSize > 0, -1);
CHECK_RETURN_CODE(lWriteSize > 0, -1);
CHECK_RETURN_CODE(lWriteSize <= lBufferSize, -1);
lResult = g_WriteFile(m_hFile, cpcBuffer, lWriteSize);
return lResult;
}
LONG File::Read(CONST PCHAR cpBuffer, LONG lBufferSize, LONG lReadSize)
{
LONG lResult = -1;
CHECK_RETURN_CODE(m_hFile, -1);
CHECK_RETURN_CODE(lBufferSize > 0, -1);
CHECK_RETURN_CODE(lReadSize > 0, -1);
CHECK_RETURN_CODE(lReadSize <= lBufferSize, -1);
lResult = g_ReadFile(m_hFile, cpBuffer, lReadSize);
return lResult;
}
static PyObject *
session_userauth_publickey_fromfile(SSH2_SessionObj *self, PyObject *args)
{
char *username;
char *publickey;
char *privatekey;
char *passphrase = "";
Py_ssize_t username_len;
int ret;
if (!PyArg_ParseTuple(args, "s#ss|s:userauth_publickey_fromfile",
&username, &username_len, &publickey, &privatekey,
&passphrase))
return NULL;
Py_BEGIN_ALLOW_THREADS
ret = libssh2_userauth_publickey_fromfile_ex(self->session, username,
username_len, publickey,
privatekey, passphrase);
Py_END_ALLOW_THREADS
CHECK_RETURN_CODE(ret, self)
Py_RETURN_NONE;
}
static PyObject *
session_userauth_publickey(SSH2_SessionObj *self, PyObject *args)
{
char *username;
char *pubkeydata;
Py_ssize_t pubkeydata_len;
PyObject *callback;
int ret;
#if PY_MAJOR_VERSION < 3
if (!PyArg_ParseTuple(args, "ss#O:userauth_publickey", &username, &pubkeydata, &pubkeydata_len, &callback))
#else
if (!PyArg_ParseTuple(args, "sy#O:userauth_publickey", &username, &pubkeydata, &pubkeydata_len, &callback))
#endif
return NULL;
if (!PyCallable_Check(callback))
return PyErr_Format(PyExc_TypeError, "'%s' is not callable", callback->ob_type->tp_name);
Py_BEGIN_ALLOW_THREADS
ret = libssh2_userauth_publickey(self->session, username,
(unsigned char*)pubkeydata, pubkeydata_len,
publickey_sign_callback, (void **)&callback);
Py_END_ALLOW_THREADS
CHECK_RETURN_CODE(ret, self)
Py_RETURN_NONE;
}
static PyObject *
session_userauth_keyboard_interactive(SSH2_SessionObj *self, PyObject *args)
{
char *username;
Py_ssize_t username_len;
PyObject *callback;
int ret;
if (!PyArg_ParseTuple(args, "s#O:userauth_keyboard_interactive",
&username, &username_len, &callback))
return NULL;
if (!PyCallable_Check(callback))
return PyErr_Format(PyExc_TypeError, "'%s' is not callable", callback->ob_type->tp_name);
Py_DECREF(self->cb_kbdint_response);
Py_INCREF(callback);
self->cb_kbdint_response = callback;
Py_BEGIN_ALLOW_THREADS
ret = libssh2_userauth_keyboard_interactive_ex(self->session, username, username_len, kbdint_response_callback);
Py_END_ALLOW_THREADS
Py_DECREF(self->cb_kbdint_response);
Py_INCREF(Py_None);
self->cb_kbdint_response = Py_None;
CHECK_RETURN_CODE(ret, self)
Py_RETURN_NONE;
}
static PyObject *
session_startup(SSH2_SessionObj *self, PyObject *args)
{
PyObject *sock;
int ret;
int fd;
if (!PyArg_ParseTuple(args, "O:startup", &sock))
return NULL;
if ((fd = PyObject_AsFileDescriptor(sock)) == -1) {
PyErr_SetString(PyExc_ValueError, "argument must be a file descriptor");
return NULL;
}
Py_BEGIN_ALLOW_THREADS
ret=libssh2_session_startup(self->session, fd);
Py_END_ALLOW_THREADS
CHECK_RETURN_CODE(ret, self)
Py_DECREF(self->socket);
Py_INCREF(sock);
self->socket = sock;
self->opened = 1;
Py_RETURN_NONE;
}
LONG File::WriteTextLine(CPCCHAR cpcStr, LONG lWriteLen)
{
LONG lResult = 0;
LONG lReCode = 0;
CHECK_RETURN_CODE(m_hFile, -1);
CHECK_RETURN_CODE(!m_bBinaryFile, -1);
CHECK_RETURN_CODE(cpcStr, -1);
CHECK_RETURN_CODE_QUIET(cpcStr[0], 0);
CHECK_RETURN_CODE_QUIET(lWriteLen != 0, 0);
CHECK_RETURN_CODE(lWriteLen > 0, -1);
LONG lStrLen = static_cast<LONG>(::strnlen(cpcStr, lWriteLen));
CHECK_RETURN_CODE(lStrLen <= lWriteLen, -1);
lReCode = g_WriteString(m_hFile, cpcStr);
CHECK_RETURN_CODE(lReCode > 0, -1);
lResult += lReCode;
lReCode = g_WriteString(m_hFile, FILE_LINE_BREAK);
CHECK_RETURN_CODE(lReCode > 0, -1);
lResult += lReCode;
return lResult;
}
static PyObject *
channel_close(SSH2_ChannelObj *self)
{
int ret;
Py_BEGIN_ALLOW_THREADS
ret = libssh2_channel_close(self->channel);
Py_END_ALLOW_THREADS
CHECK_RETURN_CODE(ret, self->session)
Py_RETURN_NONE;
}
static PyObject *
channel_shell(SSH2_ChannelObj *self)
{
int ret;
Py_BEGIN_ALLOW_THREADS
ret = libssh2_channel_process_startup(self->channel, "shell", 5, NULL, 0);
Py_END_ALLOW_THREADS
CHECK_RETURN_CODE(ret, self->session)
Py_RETURN_NONE;
}
LONG File::ReadTextLine(CONST PCHAR cpStr, LONG lReadLen)
{
LONG lResult = -1;
CHECK_RETURN_CODE(m_hFile, -1);
CHECK_RETURN_CODE(!m_bBinaryFile, -1);
CHECK_RETURN_CODE(cpStr, -1);
CHECK_RETURN_CODE_QUIET(lReadLen != 0, 0);
CHECK_RETURN_CODE(lReadLen > 0, -1);
lResult = g_ReadString(m_hFile, cpStr, lReadLen);
// 去除读取的行尾的\n
char *pNewLine = &cpStr[lResult - 1];
if (*pNewLine == '\n')
{
*pNewLine = '\0';
--lResult;
}
return lResult;
}
static PyObject *
SFTP_handle_close(SSH2_SFTP_handleObj *self)
{
int ret;
Py_BEGIN_ALLOW_THREADS
ret = libssh2_sftp_close_handle(self->sftphandle);
Py_END_ALLOW_THREADS
CHECK_RETURN_CODE(ret, self->session)
Py_RETURN_NONE;
}
static PyObject *
listener_cancel(SSH2_ListenerObj *self)
{
int ret;
Py_BEGIN_ALLOW_THREADS
ret = libssh2_channel_forward_cancel(self->listener);
Py_END_ALLOW_THREADS
CHECK_RETURN_CODE(ret, self->session)
Py_RETURN_NONE;
}
static PyObject *
session_method_pref(SSH2_SessionObj *self, PyObject *args)
{
int ret;
int method;
char *pref;
if (!PyArg_ParseTuple(args, "is:method_pref", &method, &pref))
return NULL;
ret = libssh2_session_method_pref(self->session, method, pref);
CHECK_RETURN_CODE(ret, self)
Py_RETURN_NONE;
}
static PyObject *
channel_subsystem(SSH2_ChannelObj *self, PyObject *args)
{
char *subsys;
Py_ssize_t subsys_len;
int ret;
if (!PyArg_ParseTuple(args, "s#:subsystem", &subsys, &subsys_len))
return NULL;
Py_BEGIN_ALLOW_THREADS
ret = libssh2_channel_process_startup(self->channel, "subsystem", 9, subsys, subsys_len);
Py_END_ALLOW_THREADS
CHECK_RETURN_CODE(ret, self->session)
Py_RETURN_NONE;
}
/* Can not be called just 'Channel.exec' like in the C API,
* because of 'exec' is a reserved keyword in Python 2. */
static PyObject *
channel_execute(SSH2_ChannelObj *self, PyObject *args)
{
char *cmd;
Py_ssize_t cmd_len;
int ret;
if (!PyArg_ParseTuple(args, "s#:execute", &cmd, &cmd_len))
return NULL;
Py_BEGIN_ALLOW_THREADS
ret = libssh2_channel_process_startup(self->channel, "exec", 4, cmd, cmd_len);
Py_END_ALLOW_THREADS
CHECK_RETURN_CODE(ret, self->session)
Py_RETURN_NONE;
}
static PyObject *
session_userauth_password(SSH2_SessionObj *self, PyObject *args)
{
char *username;
char *password;
Py_ssize_t username_len;
Py_ssize_t password_len;
PyObject *callback = NULL;
int ret;
if (!PyArg_ParseTuple(args, "s#s#|O:userauth_password", &username, &username_len,
&password, &password_len,
&callback))
return NULL;
if (callback != NULL) {
if (!PyCallable_Check(callback))
return PyErr_Format(PyExc_TypeError, "'%s' is not callable", callback->ob_type->tp_name);
Py_DECREF(self->cb_passwd_changereq);
Py_INCREF(callback);
self->cb_passwd_changereq = callback;
Py_BEGIN_ALLOW_THREADS
ret = libssh2_userauth_password_ex(self->session, username, username_len,
password, password_len,
passwd_changereq_callback);
Py_END_ALLOW_THREADS
Py_DECREF(self->cb_passwd_changereq);
Py_INCREF(Py_None);
self->cb_passwd_changereq = Py_None;
} else {
Py_BEGIN_ALLOW_THREADS
ret = libssh2_userauth_password_ex(self->session, username, username_len,
password, password_len,
NULL);
Py_END_ALLOW_THREADS
}
CHECK_RETURN_CODE(ret, self)
Py_RETURN_NONE;
}
static PyObject *
channel_request_pty_size(SSH2_ChannelObj *self, PyObject *args)
{
int ret;
int w = 80;
int h = 24;
if (!PyArg_ParseTuple(args, "ii:request_pty_size", &w, &h))
return NULL;
Py_BEGIN_ALLOW_THREADS
ret = libssh2_channel_request_pty_size(self->channel, w, h);
Py_END_ALLOW_THREADS
CHECK_RETURN_CODE(ret, self->session)
Py_RETURN_NONE;
}
static PyObject *
channel_setenv(SSH2_ChannelObj *self, PyObject *args)
{
char *key;
char *val;
Py_ssize_t key_len;
Py_ssize_t val_len;
int ret;
if (!PyArg_ParseTuple(args, "s#s#:setenv", &key, &key_len, &val, &val_len))
return NULL;
Py_BEGIN_ALLOW_THREADS
ret = libssh2_channel_setenv_ex(self->channel, key, key_len, val, val_len);
Py_END_ALLOW_THREADS
CHECK_RETURN_CODE(ret, self->session)
Py_RETURN_NONE;
}
static PyObject *
session_disconnect(SSH2_SessionObj *self, PyObject *args, PyObject *kwds)
{
int ret;
int reason = SSH_DISCONNECT_BY_APPLICATION;
char *description = "";
char *lang = "";
static char *kwlist[] = {"reason", "description", "lang", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iss:disconnect", kwlist, &reason, &description, &lang))
return NULL;
Py_BEGIN_ALLOW_THREADS
ret = libssh2_session_disconnect_ex(self->session, reason, description, lang);
Py_END_ALLOW_THREADS
CHECK_RETURN_CODE(ret, self)
self->opened = 0;
Py_RETURN_NONE;
}
static PyObject *
session_userauth_hostbased_fromfile(SSH2_SessionObj *self, PyObject *args)
{
char *username;
char *publickey;
char *privatekey;
char *passphrase;
char *hostname;
char *local_username = NULL;
Py_ssize_t username_len;
Py_ssize_t hostname_len;
Py_ssize_t local_username_len;
int ret;
if (!PyArg_ParseTuple(args, "s#ssss#|s#:userauth_hostbased_fromfile",
&username, &username_len,
&publickey, &privatekey, &passphrase,
&hostname, &hostname_len,
&local_username, &local_username_len))
return NULL;
if (local_username == NULL) {
local_username = username;
local_username_len = username_len;
}
Py_BEGIN_ALLOW_THREADS
ret = libssh2_userauth_hostbased_fromfile_ex(self->session,
username, username_len,
publickey, privatekey, passphrase,
hostname, hostname_len,
local_username, local_username_len);
Py_END_ALLOW_THREADS
CHECK_RETURN_CODE(ret, self)
Py_RETURN_NONE;
}
static PyObject *
channel_x11_req(SSH2_ChannelObj *self, PyObject *args, PyObject *kwds)
{
int screen_number;
int single_connection = 0;
int ret;
char *auth_proto = NULL;
char *auth_cookie = NULL;
static char *kwlist[] = {"screen_number", "single_connection", "auth_proto", "auth_cookie", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "i|iss", kwlist,
&screen_number, &single_connection,
&auth_proto, &auth_cookie))
return NULL;
Py_BEGIN_ALLOW_THREADS
ret = libssh2_channel_x11_req_ex(self->channel, single_connection, auth_proto, auth_cookie, screen_number);
Py_END_ALLOW_THREADS
CHECK_RETURN_CODE(ret, self->session)
Py_RETURN_NONE;
}
static PyObject *
channel_request_pty(SSH2_ChannelObj *self, PyObject *args)
{
char *term;
char *modes = NULL;
Py_ssize_t lt;
Py_ssize_t lm = 0;
int ret;
int w = 80;
int h = 24;
int pw = 0;
int ph = 0;
if (!PyArg_ParseTuple(args, "s#|s#iiii:request_pty", &term, <, &modes, &lm, &w, &h, &pw, &ph))
return NULL;
Py_BEGIN_ALLOW_THREADS
ret = libssh2_channel_request_pty_ex(self->channel, term, lt, modes, lm, w, h, pw, ph);
Py_END_ALLOW_THREADS
CHECK_RETURN_CODE(ret, self->session)
Py_RETURN_NONE;
}
