/*

 *

 *  BlueZ - Bluetooth protocol stack for Linux

 *

 *  Copyright (C) 2010 GSyC/LibreSoft, Universidad Rey Juan Carlos.

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This program 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 General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 *

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#define _GNU_SOURCE

#include <stdlib.h>

#include <stdint.h>

#include <stdbool.h>

#include <unistd.h>

#include <glib.h>

#include "lib/bluetooth.h"

#include "lib/l2cap.h"

#include "lib/sdp.h"

#include "gdbus/gdbus.h"

#include "src/dbus-common.h"

#include "src/log.h"

#include "src/error.h"

#include "src/adapter.h"

#include "src/device.h"

#include "src/sdpd.h"

#include "btio/btio.h"

#include "hdp_types.h"

#include "hdp_util.h"

#include "hdp.h"

#include "mcap.h"

#define ECHO_TIMEOUT	1 /* second */

#define HDP_ECHO_LEN	15

static GSList *applications = NULL;

static GSList *devices = NULL;

static uint8_t next_app_id = HDP_MDEP_INITIAL;

static GSList *adapters;

static struct hdp_device *create_health_device(struct btd_device *device);

static void free_echo_data(struct hdp_echo_data *edata);

struct hdp_create_dc {

	DBusMessage			*msg;

	struct hdp_application		*app;

	struct hdp_device		*dev;

	uint8_t				config;

	uint8_t				mdep;

	guint				ref;

	mcap_mdl_operation_cb		cb;

};

struct hdp_tmp_dc_data {

	DBusMessage			*msg;

	struct hdp_channel		*hdp_chann;

	guint				ref;

	mcap_mdl_operation_cb		cb;

};

struct hdp_echo_data {

	gboolean		echo_done;	/* Is a echo was already done */

	gpointer		buf;		/* echo packet sent */

	guint			tid;		/* echo timeout */

};

static struct hdp_channel *hdp_channel_ref(struct hdp_channel *chan)

{

	if (chan == NULL)

		return NULL;

	chan->ref++;

	DBG("(%p): ref=%d", chan, chan->ref);

	return chan;

}

static void free_health_channel(struct hdp_channel *chan)

{

	if (chan->mdep == HDP_MDEP_ECHO) {

		free_echo_data(chan->edata);

		chan->edata = NULL;

	}

	mcap_mdl_unref(chan->mdl);

	hdp_application_unref(chan->app);

	health_device_unref(chan->dev);

	g_free(chan->path);

	g_free(chan);

}

static void hdp_channel_unref(struct hdp_channel *chan)

{

	if (chan == NULL)

		return;

	chan->ref --;

	DBG("(%p): ref=%d", chan, chan->ref);

	if (chan->ref > 0)

		return;

	free_health_channel(chan);

}

static void free_hdp_create_dc(struct hdp_create_dc *dc_data)

{

	dbus_message_unref(dc_data->msg);

	hdp_application_unref(dc_data->app);

	health_device_unref(dc_data->dev);

	g_free(dc_data);

}

static struct hdp_create_dc *hdp_create_data_ref(struct hdp_create_dc *dc_data)

{

	dc_data->ref++;

	DBG("(%p): ref=%d", dc_data, dc_data->ref);

	return dc_data;

}

static void hdp_create_data_unref(struct hdp_create_dc *dc_data)

{

	dc_data->ref--;

	DBG("(%p): ref=%d", dc_data, dc_data->ref);

	if (dc_data->ref > 0)

		return;

	free_hdp_create_dc(dc_data);

}

static void free_hdp_conn_dc(struct hdp_tmp_dc_data *data)

{

	dbus_message_unref(data->msg);

	hdp_channel_unref(data->hdp_chann);

	g_free(data);

}

static struct hdp_tmp_dc_data *hdp_tmp_dc_data_ref(struct hdp_tmp_dc_data *data)

{

	data->ref++;

	DBG("hdp_conn_data_ref(%p): ref=%d", data, data->ref);

	return data;

}

static void hdp_tmp_dc_data_unref(struct hdp_tmp_dc_data *data)

{

	data->ref--;

	DBG("hdp_conn_data_unref(%p): ref=%d", data, data->ref);

	if (data->ref > 0)

		return;

	free_hdp_conn_dc(data);

}

static int cmp_app_id(gconstpointer a, gconstpointer b)

{

	const struct hdp_application *app = a;

	const uint8_t *id = b;

	return app->id - *id;

}

static int cmp_adapter(gconstpointer a, gconstpointer b)

{

	const struct hdp_adapter *hdp_adapter = a;

	const struct btd_adapter *adapter = b;

	if (hdp_adapter->btd_adapter == adapter)

		return 0;

	return -1;

}

static int cmp_device(gconstpointer a, gconstpointer b)

{

	const struct hdp_device *hdp_device = a;

	const struct btd_device *device = b;

	if (hdp_device->dev == device)

		return 0;

	return -1;

}

static int cmp_dev_addr(gconstpointer a, gconstpointer dst)

{

	const struct hdp_device *device = a;

	return bacmp(device_get_address(device->dev), dst);

}

static int cmp_dev_mcl(gconstpointer a, gconstpointer mcl)

{

	const struct hdp_device *device = a;

	if (mcl == device->mcl)

		return 0;

	return -1;

}

static int cmp_chan_mdlid(gconstpointer a, gconstpointer b)

{

	const struct hdp_channel *chan = a;

	const uint16_t *mdlid = b;

	return chan->mdlid - *mdlid;

}

static int cmp_chan_path(gconstpointer a, gconstpointer b)

{

	const struct hdp_channel *chan = a;

	const char *path = b;

	return g_ascii_strcasecmp(chan->path, path);

}

static int cmp_chan_mdl(gconstpointer a, gconstpointer mdl)

{

	const struct hdp_channel *chan = a;

	if (chan->mdl == mdl)

		return 0;

	return -1;

}

static uint8_t get_app_id(void)

{

	uint8_t id = next_app_id;

	do {

		GSList *l = g_slist_find_custom(applications, &id, cmp_app_id);

		if (l == NULL) {

			next_app_id = (id % HDP_MDEP_FINAL) + 1;

			return id;

		} else

			id = (id % HDP_MDEP_FINAL) + 1;

	} while (id != next_app_id);

	/* No more ids available */

	return 0;

}

static int cmp_app(gconstpointer a, gconstpointer b)

{

	const struct hdp_application *app = a;

	return g_strcmp0(app->path, b);

}

static gboolean set_app_path(struct hdp_application *app)

{

	app->id = get_app_id();

	if (app->id == 0)

		return FALSE;

	app->path = g_strdup_printf(MANAGER_PATH "/health_app_%d", app->id);

	return TRUE;

};

static void device_unref_mcl(struct hdp_device *hdp_device)

{

	if (hdp_device->mcl == NULL)

		return;

	mcap_close_mcl(hdp_device->mcl, FALSE);

	mcap_mcl_unref(hdp_device->mcl);

	hdp_device->mcl = NULL;

	hdp_device->mcl_conn = FALSE;

}

static void free_health_device(struct hdp_device *device)

{

	if (device->dev != NULL) {

		btd_device_unref(device->dev);

		device->dev = NULL;

	}

	device_unref_mcl(device);

	g_free(device);

}

static void update_adapter_cb(void *data, void *user_data);

static void remove_application(struct hdp_application *app)

{

	DBG("Application %s deleted", app->path);

	hdp_application_unref(app);

	g_slist_foreach(adapters, update_adapter_cb, NULL);

}

static void client_disconnected(DBusConnection *conn, void *user_data)

{

	struct hdp_application *app = user_data;

	DBG("Client disconnected from the bus, deleting hdp application");

	applications = g_slist_remove(applications, app);

	app->dbus_watcher = 0; /* Watcher shouldn't be freed in this case */

	remove_application(app);

}

static DBusMessage *manager_create_application(DBusConnection *conn,

					DBusMessage *msg, void *user_data)

{

	struct hdp_application *app;

	const char *name;

	DBusMessageIter iter;

	GError *err = NULL;

	dbus_message_iter_init(msg, &iter);

	app = hdp_get_app_config(&iter, &err;;

	if (err != NULL) {

		g_error_free(err);

		return btd_error_invalid_args(msg);

	}

	name = dbus_message_get_sender(msg);

	if (name == NULL) {

		hdp_application_unref(app);

		return g_dbus_create_error(msg,

					ERROR_INTERFACE ".HealthError",

					"Can't get sender name");

	}

	if (!set_app_path(app)) {

		hdp_application_unref(app);

		return g_dbus_create_error(msg,

				ERROR_INTERFACE ".HealthError",

				"Can't get a valid id for the application");

	}

	app->oname = g_strdup(name);

	applications = g_slist_prepend(applications, app);

	app->dbus_watcher =

			g_dbus_add_disconnect_watch(btd_get_dbus_connection(),

					name, client_disconnected, app, NULL);

	g_slist_foreach(adapters, update_adapter_cb, NULL);

	DBG("Health application created with id %s", app->path);

	return g_dbus_create_reply(msg, DBUS_TYPE_OBJECT_PATH, &app->path,

							DBUS_TYPE_INVALID);

}

static DBusMessage *manager_destroy_application(DBusConnection *conn,

					DBusMessage *msg, void *user_data)

{

	const char *path;

	struct hdp_application *app;

	GSList *l;

	if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,

						DBUS_TYPE_INVALID))

		return btd_error_invalid_args(msg);

	l = g_slist_find_custom(applications, path, cmp_app);

	if (l == NULL)

		return g_dbus_create_error(msg,

					ERROR_INTERFACE ".InvalidArguments",

					"Invalid arguments in method call, "

					"no such application");

	app = l->data;

	applications = g_slist_remove(applications, app);

	remove_application(app);

	return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);

}

static void application_unref(void *data, void *user_data)

{

	hdp_application_unref(data);

}

static void manager_path_unregister(gpointer data)

{

	g_slist_foreach(applications, application_unref, NULL);

	g_slist_free(applications);

	applications = NULL;

	g_slist_foreach(adapters, update_adapter_cb, NULL);

}

static const GDBusMethodTable health_manager_methods[] = {

	{ GDBUS_METHOD("CreateApplication",

			GDBUS_ARGS({ "config", "a{sv}" }),

			GDBUS_ARGS({ "application", "o" }),

			manager_create_application) },

	{ GDBUS_METHOD("DestroyApplication",

			GDBUS_ARGS({ "application", "o" }), NULL,

			manager_destroy_application) },

	{ }

};

static gboolean channel_property_get_device(const GDBusPropertyTable *property,

					DBusMessageIter *iter, void *data)

{

	struct hdp_channel *chan = data;

	const char *path = device_get_path(chan->dev->dev);

	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);

	return TRUE;

}

static gboolean channel_property_get_application(

					const GDBusPropertyTable *property,

					DBusMessageIter *iter, void *data)

{

	struct hdp_channel *chan = data;

	const char *path = chan->app->path;

	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);

	return TRUE;

}

static gboolean channel_property_get_type(const GDBusPropertyTable *property,

					DBusMessageIter *iter, void *data)

{

	struct hdp_channel *chan = data;

	const char *type;

	if (chan->config == HDP_RELIABLE_DC)

		type = "reliable";

	else

		type = "streaming";

	dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &type);

	return TRUE;

}

static void hdp_tmp_dc_data_destroy(gpointer data)

{

	struct hdp_tmp_dc_data *hdp_conn = data;

	hdp_tmp_dc_data_unref(hdp_conn);

}

static void abort_mdl_cb(GError *err, gpointer data)

{

	if (err != NULL)

		error("Aborting error: %s", err->message);

}

static void hdp_mdl_reconn_cb(struct mcap_mdl *mdl, GError *err, gpointer data)

{

	DBusConnection *conn = btd_get_dbus_connection();

	struct hdp_tmp_dc_data *dc_data = data;

	DBusMessage *reply;

	int fd;

	if (err != NULL) {

		struct hdp_channel *chan = dc_data->hdp_chann;

		GError *gerr = NULL;

		error("%s", err->message);

		reply = g_dbus_create_error(dc_data->msg,

					ERROR_INTERFACE ".HealthError",

					"Cannot reconnect: %s", err->message);

		g_dbus_send_message(conn, reply);

		/* Send abort request because remote side */

		/* is now in PENDING state */

		if (!mcap_mdl_abort(chan->mdl, abort_mdl_cb, NULL, NULL,

								&gerr)) {

			error("%s", gerr->message);

			g_error_free(gerr);

		}

		return;

	}

	fd = mcap_mdl_get_fd(dc_data->hdp_chann->mdl);

	if (fd < 0) {

		reply = g_dbus_create_error(dc_data->msg,

						ERROR_INTERFACE ".HealthError",

						"Cannot get file descriptor");

		g_dbus_send_message(conn, reply);

		return;

	}

	reply = g_dbus_create_reply(dc_data->msg, DBUS_TYPE_UNIX_FD,

							&fd, DBUS_TYPE_INVALID);

	g_dbus_send_message(conn, reply);

	g_dbus_emit_signal(conn, device_get_path(dc_data->hdp_chann->dev->dev),

			HEALTH_DEVICE, "ChannelConnected",

			DBUS_TYPE_OBJECT_PATH, &dc_data->hdp_chann->path,

			DBUS_TYPE_INVALID);

}

static void hdp_get_dcpsm_cb(uint16_t dcpsm, gpointer user_data, GError *err)

{

	struct hdp_tmp_dc_data *hdp_conn = user_data;

	struct hdp_channel *hdp_chann = hdp_conn->hdp_chann;

	GError *gerr = NULL;

	uint8_t mode;

	if (err != NULL) {

		hdp_conn->cb(hdp_chann->mdl, err, hdp_conn);

		return;

	}

	if (hdp_chann->config == HDP_RELIABLE_DC)

		mode = L2CAP_MODE_ERTM;

	else

		mode = L2CAP_MODE_STREAMING;

	if (mcap_connect_mdl(hdp_chann->mdl, mode, dcpsm, hdp_conn->cb,

					hdp_tmp_dc_data_ref(hdp_conn),

					hdp_tmp_dc_data_destroy, &gerr))

		return;

	hdp_conn->cb(hdp_chann->mdl, err, hdp_conn);

	g_error_free(gerr);

	hdp_tmp_dc_data_unref(hdp_conn);

}

static void device_reconnect_mdl_cb(struct mcap_mdl *mdl, GError *err,

								gpointer data)

{

	DBusConnection *conn = btd_get_dbus_connection();

	struct hdp_tmp_dc_data *dc_data = data;

	GError *gerr = NULL;

	DBusMessage *reply;

	if (err != NULL) {

		reply = g_dbus_create_error(dc_data->msg,

					ERROR_INTERFACE ".HealthError",

					"Cannot reconnect: %s", err->message);

		g_dbus_send_message(conn, reply);

		return;

	}

	dc_data->cb = hdp_mdl_reconn_cb;

	if (hdp_get_dcpsm(dc_data->hdp_chann->dev, hdp_get_dcpsm_cb,

					hdp_tmp_dc_data_ref(dc_data),

					hdp_tmp_dc_data_destroy, &gerr))

		return;

	error("%s", gerr->message);

	reply = g_dbus_create_error(dc_data->msg,

					ERROR_INTERFACE ".HealthError",

					"Cannot reconnect: %s", gerr->message);

	g_dbus_send_message(conn, reply);

	hdp_tmp_dc_data_unref(dc_data);

	g_error_free(gerr);

	/* Send abort request because remote side is now in PENDING state */

	if (!mcap_mdl_abort(mdl, abort_mdl_cb, NULL, NULL, &gerr)) {

		error("%s", gerr->message);

		g_error_free(gerr);

	}

}

static DBusMessage *channel_acquire_continue(struct hdp_tmp_dc_data *data,

								GError *err)

{

	DBusMessage *reply;

	GError *gerr = NULL;

	int fd;

	if (err != NULL) {

		return g_dbus_create_error(data->msg,

						ERROR_INTERFACE ".HealthError",

						"%s", err->message);

	}

	fd = mcap_mdl_get_fd(data->hdp_chann->mdl);

	if (fd >= 0)

		return g_dbus_create_reply(data->msg, DBUS_TYPE_UNIX_FD, &fd,

							DBUS_TYPE_INVALID);

	hdp_tmp_dc_data_ref(data);

	if (mcap_reconnect_mdl(data->hdp_chann->mdl, device_reconnect_mdl_cb,

					data, hdp_tmp_dc_data_destroy, &gerr))

		return NULL;

	reply = g_dbus_create_error(data->msg, ERROR_INTERFACE ".HealthError",

					"Cannot reconnect: %s", gerr->message);

	g_error_free(gerr);

	hdp_tmp_dc_data_unref(data);

	return reply;

}

static void channel_acquire_cb(gpointer data, GError *err)

{

	DBusMessage *reply;

	reply = channel_acquire_continue(data, err);

	if (reply != NULL)

		g_dbus_send_message(btd_get_dbus_connection(), reply);

}

static DBusMessage *channel_acquire(DBusConnection *conn,

					DBusMessage *msg, void *user_data)

{

	struct hdp_channel *chan = user_data;

	struct hdp_tmp_dc_data *dc_data;

	GError *gerr = NULL;

	DBusMessage *reply;

	dc_data = g_new0(struct hdp_tmp_dc_data, 1);

	dc_data->msg = dbus_message_ref(msg);

	dc_data->hdp_chann = hdp_channel_ref(chan);

	if (chan->dev->mcl_conn) {

		reply = channel_acquire_continue(hdp_tmp_dc_data_ref(dc_data),

									NULL);

		hdp_tmp_dc_data_unref(dc_data);

		return reply;

	}

	if (hdp_establish_mcl(chan->dev, channel_acquire_cb,

						hdp_tmp_dc_data_ref(dc_data),

						hdp_tmp_dc_data_destroy, &gerr))

		return NULL;

	reply = g_dbus_create_error(msg, ERROR_INTERFACE ".HealthError",

					"%s", gerr->message);

	hdp_tmp_dc_data_unref(dc_data);

	g_error_free(gerr);

	return reply;

}

static void close_mdl(struct hdp_channel *hdp_chann)

{

	int fd;

	fd = mcap_mdl_get_fd(hdp_chann->mdl);

	if (fd < 0)

		return;

	close(fd);

}

static DBusMessage *channel_release(DBusConnection *conn,

					DBusMessage *msg, void *user_data)

{

	struct hdp_channel *hdp_chann = user_data;

	close_mdl(hdp_chann);

	return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);

}

static void free_echo_data(struct hdp_echo_data *edata)

{

	if (edata == NULL)

		return;

	if (edata->tid > 0)

		g_source_remove(edata->tid);

	if (edata->buf != NULL)

		g_free(edata->buf);

	g_free(edata);

}

static void health_channel_destroy(void *data)

{

	struct hdp_channel *hdp_chan = data;

	struct hdp_device *dev = hdp_chan->dev;

	DBG("Destroy Health Channel %s", hdp_chan->path);

	if (g_slist_find(dev->channels, hdp_chan) == NULL)

		goto end;

	dev->channels = g_slist_remove(dev->channels, hdp_chan);

	if (hdp_chan->mdep != HDP_MDEP_ECHO)

		g_dbus_emit_signal(btd_get_dbus_connection(),

					device_get_path(dev->dev),

					HEALTH_DEVICE, "ChannelDeleted",

					DBUS_TYPE_OBJECT_PATH, &hdp_chan->path,

					DBUS_TYPE_INVALID);

	if (hdp_chan == dev->fr) {

		hdp_channel_unref(dev->fr);

		dev->fr = NULL;

	}

end:

	hdp_channel_unref(hdp_chan);

}

static const GDBusMethodTable health_channels_methods[] = {

	{ GDBUS_ASYNC_METHOD("Acquire",

			NULL, GDBUS_ARGS({ "fd", "h" }),

			channel_acquire) },

	{ GDBUS_METHOD("Release", NULL, NULL, channel_release) },

	{ }

};

static const GDBusPropertyTable health_channels_properties[] = {

	{ "Device", "o",  channel_property_get_device },

	{ "Application", "o", channel_property_get_application },

	{ "Type", "s", channel_property_get_type },

	{ }

};

static struct hdp_channel *create_channel(struct hdp_device *dev,

						uint8_t config,

						struct mcap_mdl *mdl,

						uint16_t mdlid,

						struct hdp_application *app,

						GError **err)

{

	struct hdp_channel *hdp_chann;

	if (dev == NULL) {

		g_set_error(err, HDP_ERROR, HDP_UNSPECIFIED_ERROR,

					"HDP device uninitialized");

		return NULL;

	}

	hdp_chann = g_new0(struct hdp_channel, 1);

	hdp_chann->config = config;

	hdp_chann->dev = health_device_ref(dev);

	hdp_chann->mdlid = mdlid;

	if (mdl != NULL)

		hdp_chann->mdl = mcap_mdl_ref(mdl);

	if (app != NULL) {

		hdp_chann->mdep = app->id;

		hdp_chann->app = hdp_application_ref(app);

	} else

		hdp_chann->edata = g_new0(struct hdp_echo_data, 1);

	hdp_chann->path = g_strdup_printf("%s/chan%d",

					device_get_path(hdp_chann->dev->dev),

					hdp_chann->mdlid);

	dev->channels = g_slist_append(dev->channels,

						hdp_channel_ref(hdp_chann));

	if (hdp_chann->mdep == HDP_MDEP_ECHO)

		return hdp_channel_ref(hdp_chann);

	if (!g_dbus_register_interface(btd_get_dbus_connection(),

					hdp_chann->path, HEALTH_CHANNEL,

					health_channels_methods, NULL,

					health_channels_properties, hdp_chann,

					health_channel_destroy)) {

		g_set_error(err, HDP_ERROR, HDP_UNSPECIFIED_ERROR,

					"Can't register the channel interface");

		health_channel_destroy(hdp_chann);

		return NULL;

	}

	return hdp_channel_ref(hdp_chann);

}

static void remove_channels(struct hdp_device *dev)

{

	struct hdp_channel *chan;

	char *path;

	while (dev->channels != NULL) {

		chan = dev->channels->data;

		path = g_strdup(chan->path);

		if (!g_dbus_unregister_interface(btd_get_dbus_connection(),

							path, HEALTH_CHANNEL))

			health_channel_destroy(chan);

		g_free(path);

	}

}

static void close_device_con(struct hdp_device *dev, gboolean cache)

{

	if (dev->mcl == NULL)

		return;

	mcap_close_mcl(dev->mcl, cache);

	dev->mcl_conn = FALSE;

	if (cache)

		return;

	device_unref_mcl(dev);

	remove_channels(dev);

	if (!dev->sdp_present) {

		const char *path;

		path = device_get_path(dev->dev);

		g_dbus_unregister_interface(btd_get_dbus_connection(),

							path, HEALTH_DEVICE);

	}

}

static int send_echo_data(int sock, const void *buf, uint32_t size)

{

	const uint8_t *buf_b = buf;

	uint32_t sent = 0;

	while (sent < size) {

		int n = write(sock, buf_b + sent, size - sent);

		if (n < 0)

			return -1;

		sent += n;

	}

	return 0;

}

static gboolean serve_echo(GIOChannel *io_chan, GIOCondition cond,

								gpointer data)

{

	struct hdp_channel *chan = data;

	uint8_t buf[MCAP_DC_MTU];

	int fd, len;

	if (cond & (G_IO_ERR | G_IO_HUP | G_IO_NVAL)) {

		hdp_channel_unref(chan);

		return FALSE;

	}

	if (chan->edata->echo_done)

		goto fail;

	chan->edata->echo_done = TRUE;

	fd = g_io_channel_unix_get_fd(io_chan);

	len = read(fd, buf, sizeof(buf));

	if (len < 0)

		goto fail;

	if (send_echo_data(fd, buf, len)  >= 0)