int ne_mkcol(ne_session *sess, const char *uri)
{
ne_request *req;
char *real_uri;
int ret;
if (ne_path_has_trailing_slash(uri)) {
real_uri = ne_strdup(uri);
} else {
real_uri = ne_concat(uri, "/", NULL);
}
req = ne_request_create(sess, "MKCOL", real_uri);
#ifdef NE_HAVE_DAV
ne_lock_using_resource(req, real_uri, 0);
ne_lock_using_parent(req, real_uri);
#endif
ret = ne_simple_request(sess, req);
ne_free(real_uri);
return ret;
}
/* TODO: implement properly */
int ne_path_compare(const char *a, const char *b)
{
int ret = ne_strcasecmp(a, b);
if (ret) {
/* This logic says: "If the lengths of the two URIs differ by
* exactly one, and the LONGER of the two URIs has a trailing
* slash and the SHORTER one DOESN'T, then..." */
int traila = ne_path_has_trailing_slash(a),
trailb = ne_path_has_trailing_slash(b),
lena = strlen(a), lenb = strlen(b);
if (traila != trailb && abs(lena - lenb) == 1 &&
((traila && lena > lenb) || (trailb && lenb > lena))) {
/* Compare them, ignoring the trailing slash on the longer
* URI */
if (strncasecmp(a, b, lena < lenb ? lena : lenb) == 0)
ret = 0;
}
}
return ret;
}
int init(void)
{
ne_uri u = {0}, proxy = {0};
int optc, n;
char *proxy_url = NULL;
char str[64], *src;
int i;
if ((times1=malloc(sizeof(float)*pget_option.requests)) == NULL){
perror("malloc(times1) :");
exit(-1);
}
if ((times2=malloc(sizeof(float)*pget_option.requests)) == NULL){
perror("malloc(times2) :");
exit(-1);
}
while ((optc = getopt_long(test_argc, test_argv,
"d:hp", longopts, NULL)) != -1) {
switch (optc) {
case 'd':
htdocs_root = optarg;
break;
case 'p':
proxy_url = optarg;
break;
default:
exit(1);
}
}
n = test_argc - optind;
if (n == 0 || n > 3 || n == 2) {
exit(1);
}
if (htdocs_root == NULL)
htdocs_root = "htdocs";
if (ne_uri_parse(test_argv[optind], &u)) {
t_context("couldn't parse server URL `%s'",
test_argv[optind]);
return FAILHARD;
}
if (proxy_url) {
if (ne_uri_parse(proxy_url, &proxy)) {
t_context("couldn't parse proxy URL `%s'", proxy_url);
return FAILHARD;
}
if (proxy.scheme && strcmp(proxy.scheme, "http") != 0) {
t_context("cannot use scheme `%s' for proxy", proxy.scheme);
return FAILHARD;
}
if (proxy.port > 0) {
proxy_port = proxy.port;
} else {
proxy_port = 8080;
}
proxy_hostname = proxy.host;
}
if (u.scheme && strcmp(u.scheme, "https") == 0)
use_secure = 1;
i_hostname = u.host;
if (u.port > 0) {
i_port = u.port;
} else {
if (use_secure) {
i_port = 443;
} else {
i_port = 80;
}
}
if (ne_path_has_trailing_slash(u.path)) {
i_path = u.path;
} else {
i_path = ne_concat(u.path, "/", NULL);
}
i_path = ne_path_escape(i_path);
if (n > 2) {
i_username = test_argv[optind+1];
i_password = test_argv[optind+2];
if (strlen(i_username) >= NE_ABUFSIZ) {
t_context("username must be <%d chars", NE_ABUFSIZ);
return FAILHARD;
}
if (strlen(i_password) >= NE_ABUFSIZ) {
t_context("password must be <%d chars", NE_ABUFSIZ);
return FAILHARD;
}
}
if (proxy_hostname)
CALL(test_resolve(proxy_hostname, "proxy server"));
else
CALL(test_resolve(i_hostname, "server"));
CALL(open_foo());
CALL(test_connect());
printf("Done\n");
return OK;
}
static char *remote_completion(const char *text, int state)
{
static struct resource *reslist, *current;
static int len;
static time_t last_fetch;
static char *last_path;
char *name;
if (state == 0) {
/* Check to see if we should refresh the dumb cache.
* or, initialize the local cache of remote filenames
* The remote resource list persists until a completion
* in a new context is requested or the cache expires.
*/
/* TODO get cache expire time from config, currently from cadaver.h
* TODO cache and fetch on deep/absolute paths: (path: /a/b/, text: c/d)
*/
if (last_fetch < (time(NULL) - COMPLETION_CACHE_EXPIRE)
|| !last_path
|| strcmp(session.uri.path, last_path) != 0) {
if (last_path != NULL) {
free(last_path);
}
if (reslist != NULL) {
free_resource_list(reslist);
}
/* Hide the connection status */
ne_set_notifier(session.sess, NULL, NULL);
if (fetch_resource_list(session.sess, session.uri.path, 1, 0,
&reslist) != NE_OK) {
reslist = NULL;
}
/* Restore the session connection printing */
ne_set_notifier(session.sess, notifier, NULL);
last_path = ne_strdup(session.uri.path);
}
current = reslist;
len = strlen(text);
time(&last_fetch);
}
while (current) {
/* Massage the absolute URI to a URI relative to our path */
/* Copy & paste & search & replace from ls.c */
if (ne_path_has_trailing_slash(current->uri)) {
current->uri[strlen(current->uri)-1] = '\0';
}
name = strrchr(current->uri, '/');
if (name != NULL && strlen(name+1) > 0) {
name++;
} else {
name = current->uri;
}
name = ne_path_unescape(name);
if (strncmp(text, name, len) == 0) {
current = current->next;
/* FIXME: readline docs say readline will free() this when
* it's finished with, although 'memprof' shows that it
* leaks. */
return name;
}
current = current->next;
}
return NULL;
}
/* FIXME: Leaky as a bucket */
void open_connection(const char *url)
{
char *proxy_host = get_option(opt_proxy), *pnt;
ne_server_capabilities caps;
int ret, use_ssl = 0;
ne_session *sess;
if (session.connected) {
close_connection();
} else {
ne_uri_free(&session.uri);
if (session.lastwp) {
ne_free(session.lastwp);
session.lastwp = NULL;
}
}
/* Single argument: see whether we have a path or scheme */
if (strchr(url, '/') == NULL) {
/* No path, no scheme -> just a hostname */
pnt = strchr(url, ':');
if (pnt != NULL) {
*pnt++ = '\0';
session.uri.port = atoi(pnt);
} else {
session.uri.port = 80;
}
session.uri.host = ne_strdup(url);
session.uri.scheme = ne_strdup("http");
} else {
/* Parse the URL */
if (ne_uri_parse(url, &session.uri) || session.uri.host == NULL) {
printf(_("Could not parse URL `%s'\n"), url);
return;
}
if (session.uri.scheme == NULL)
session.uri.scheme = ne_strdup("http");
if (!session.uri.port)
session.uri.port = ne_uri_defaultport(session.uri.scheme);
if (strcasecmp(session.uri.scheme, "https") == 0) {
if (!ne_has_support(NE_FEATURE_SSL)) {
printf(_("SSL is not enabled.\n"));
return;
}
use_ssl = 1;
}
}
session.sess = ne_session_create(session.uri.scheme, session.uri.host,
session.uri.port);
sess = session.sess;
if (use_ssl && setup_ssl()) {
return;
}
ne_lockstore_register(session.locks, sess);
ne_redirect_register(sess);
ne_set_notifier(sess, notifier, NULL);
if (session.uri.path == NULL) {
session.uri.path = ne_strdup("/");
} else {
if (!ne_path_has_trailing_slash(session.uri.path)) {
pnt = ne_concat(session.uri.path, "/", NULL);
free(session.uri.path);
session.uri.path = pnt;
}
}
/* Get the proxy details */
if (proxy_host != NULL) {
if (get_option(opt_proxy_port) != NULL) {
proxy_port = atoi(get_option(opt_proxy_port));
} else {
proxy_port = 8080;
}
proxy_hostname = proxy_host;
}
#ifdef ENABLE_NETRC
{
netrc_entry *found;
found = search_netrc(netrc_list, session.uri.host);
if (found != NULL) {
if (found->account && found->password) {
server_username = found->account;
server_password = found->password;
}
}
}
#endif /* ENABLE_NETRC */
#ifdef NE_SESSFLAG_EXPECT100
ne_set_session_flag(session.sess, NE_SESSFLAG_EXPECT100, get_bool_option(opt_expect100));
#endif /* NE_SESSFLAG_EXPECT100 */
session.connected = 0;
ne_set_useragent(session.sess, "cadaver/" PACKAGE_VERSION);
ne_set_server_auth(session.sess, supply_creds_server, NULL);
ne_set_proxy_auth(session.sess, supply_creds_proxy, NULL);
if (proxy_host) {
ne_session_proxy(session.sess, proxy_hostname, proxy_port);
}
ret = ne_options(session.sess, session.uri.path, &caps);
switch (ret) {
case NE_OK:
session.connected = true;
if (set_path(session.uri.path)) {
close_connection();
}
break;
case NE_CONNECT:
if (proxy_host) {
printf(_("Could not connect to `%s' on port %d:\n%s\n"),
proxy_hostname, proxy_port, ne_get_error(session.sess));
} else {
printf(_("Could not connect to `%s' on port %d:\n%s\n"),
session.uri.host, session.uri.port, ne_get_error(session.sess));
}
break;
case NE_LOOKUP:
puts(ne_get_error(session.sess));
break;
default:
printf(_("Could not open collection:\n%s\n"),
ne_get_error(session.sess));
break;
}
}
