static int
pppoe_session_send_PADT(pppoe_session *_this)
{
u_char bufspace[2048];
bytebuffer *buf;
struct pppoe_header pppoe;
int rval = 0;
struct pppoe_tlv tlv;
if ((buf = bytebuffer_wrap(bufspace, sizeof(bufspace))) == NULL) {
pppoe_session_log(_this, LOG_ERR,
"bytebuffer_wrap() failed on %s(): %m", __func__);
return -1;
}
bytebuffer_clear(buf);
/*
* PPPoE Header
*/
memset(&pppoe, 0, sizeof(pppoe));
pppoe.ver = PPPOE_RFC2516_VER;
pppoe.type = PPPOE_RFC2516_TYPE;
pppoe.code = PPPOE_CODE_PADT;
pppoe.session_id = htons(_this->session_id);
bytebuffer_put(buf, &pppoe, sizeof(pppoe));
/*
* Tag - End-of-List
*/
tlv.type = htons(PPPOE_TAG_END_OF_LIST);
tlv.length = 0;
bytebuffer_put(buf, &tlv, sizeof(tlv));
tlv.type = htons(PPPOE_TAG_END_OF_LIST);
tlv.length = 0;
bytebuffer_put(buf, &tlv, sizeof(tlv));
bytebuffer_flip(buf);
if (pppoe_session_output(_this, 1, bytebuffer_pointer(buf),
bytebuffer_remaining(buf)) != 0) {
pppoe_session_log(_this, LOG_ERR, "pppoed_output failed: %m");
rval = 1;
}
pppoe_session_log(_this, LOG_INFO, "SendPADT");
bytebuffer_unwrap(buf);
bytebuffer_destroy(buf);
return rval;
}
GhtErr
ght_writer_free(GhtWriter *writer)
{
if ( ! writer ) return GHT_ERROR;
if ( writer->type == GHT_IO_MEM )
{
bytebuffer_destroy(writer->bytebuffer);
}
else if ( writer->type == GHT_IO_FILE )
{
if ( writer->file )
fclose(writer->file);
if ( writer->filename )
ght_free(writer->filename);
}
ght_free(writer);
return GHT_OK;
}
/* send PADS */
static int
pppoe_session_send_PADS(pppoe_session *_this, struct pppoe_tlv *hostuniq,
struct pppoe_tlv *service_name)
{
int rval, len;
u_char bufspace[2048], msgbuf[80];
bytebuffer *buf;
struct pppoe_header pppoe;
struct pppoe_tlv tlv;
if ((buf = bytebuffer_wrap(bufspace, sizeof(bufspace))) == NULL) {
pppoe_session_log(_this, LOG_ERR,
"bytebuffer_wrap() failed on %s(): %m", __func__);
return -1;
}
bytebuffer_clear(buf);
/*
* PPPoE Header
*/
memset(&pppoe, 0, sizeof(pppoe));
pppoe.ver = PPPOE_RFC2516_VER;
pppoe.type = PPPOE_RFC2516_TYPE;
pppoe.code = PPPOE_CODE_PADS;
pppoe.session_id = htons(_this->session_id);
bytebuffer_put(buf, &pppoe, sizeof(pppoe));
/*
* Tag - Service-Name
*/
msgbuf[0] = '\0';
if (service_name != NULL) {
tlv.type = htons(PPPOE_TAG_SERVICE_NAME);
tlv.length = htons(service_name->length);
bytebuffer_put(buf, &tlv, sizeof(tlv));
len = service_name->length;
if (len > 0) {
bytebuffer_put(buf, service_name->value, len);
strlcpy(msgbuf, service_name->value,
MIN(len + 1, sizeof(msgbuf)));
}
}
/*
* Tag - Host-Uniq
*/
if (hostuniq != NULL) {
tlv.type = htons(PPPOE_TAG_HOST_UNIQ);
tlv.length = htons(hostuniq->length);
bytebuffer_put(buf, &tlv, sizeof(tlv));
bytebuffer_put(buf, hostuniq->value, hostuniq->length);
}
tlv.type = htons(PPPOE_TAG_END_OF_LIST);
tlv.length = 0;
bytebuffer_put(buf, &tlv, sizeof(tlv));
bytebuffer_flip(buf);
rval = 0;
if (pppoe_session_output(_this, 1, bytebuffer_pointer(buf),
bytebuffer_remaining(buf)) != 0) {
pppoe_session_log(_this, LOG_ERR, "pppoed_output failed: %m");
rval = 1;
}
pppoe_session_log(_this, LOG_INFO, "SendPADS serviceName=%s "
"hostUniq=%s", msgbuf,
hostuniq? pppoed_tlv_value_string(hostuniq) : "none");
bytebuffer_unwrap(buf);
bytebuffer_destroy(buf);
return rval;
}
static int lwgeom_write_to_buffer(const LWGEOM *geom, TWKB_GLOBALS *globals, TWKB_STATE *parent_state)
{
int i, is_empty, has_z, has_m, ndims;
size_t bbox_size = 0, optional_precision_byte = 0;
uint8_t flag = 0, type_prec = 0;
TWKB_STATE child_state;
memset(&child_state, 0, sizeof(TWKB_STATE));
child_state.header_buf = bytebuffer_create_with_size(16);
child_state.geom_buf = bytebuffer_create_with_size(64);
child_state.idlist = parent_state->idlist;
/* Read dimensionality from input */
has_z = lwgeom_has_z(geom);
has_m = lwgeom_has_m(geom);
ndims = lwgeom_ndims(geom);
is_empty = lwgeom_is_empty(geom);
/* Do we need extended precision? If we have a Z or M we do. */
optional_precision_byte = (has_z || has_m);
/* Both X and Y dimension use the same precision */
globals->factor[0] = pow(10, globals->prec_xy);
globals->factor[1] = globals->factor[0];
/* Z and M dimensions have their own precisions */
if ( has_z )
globals->factor[2] = pow(10, globals->prec_z);
if ( has_m )
globals->factor[2 + has_z] = pow(10, globals->prec_m);
/* Reset stats */
for ( i = 0; i < MAX_N_DIMS; i++ )
{
/* Reset bbox calculation */
child_state.bbox_max[i] = INT64_MIN;
child_state.bbox_min[i] = INT64_MAX;
/* Reset acumulated delta values to get absolute values on next point */
child_state.accum_rels[i] = 0;
}
/* TYPE/PRECISION BYTE */
if ( abs(globals->prec_xy) > 7 )
lwerror("%s: X/Z precision cannot be greater than 7 or less than -7", __func__);
/* Read the TWKB type number from the geometry */
TYPE_PREC_SET_TYPE(type_prec, lwgeom_twkb_type(geom));
/* Zig-zag the precision value before encoding it since it is a signed value */
TYPE_PREC_SET_PREC(type_prec, zigzag8(globals->prec_xy));
/* Write the type and precision byte */
bytebuffer_append_byte(child_state.header_buf, type_prec);
/* METADATA BYTE */
/* Set first bit if we are going to store bboxes */
FIRST_BYTE_SET_BBOXES(flag, (globals->variant & TWKB_BBOX) && ! is_empty);
/* Set second bit if we are going to store resulting size */
FIRST_BYTE_SET_SIZES(flag, globals->variant & TWKB_SIZE);
/* There will be no ID-list (for now) */
FIRST_BYTE_SET_IDLIST(flag, parent_state->idlist && ! is_empty);
/* Are there higher dimensions */
FIRST_BYTE_SET_EXTENDED(flag, optional_precision_byte);
/* Empty? */
FIRST_BYTE_SET_EMPTY(flag, is_empty);
/* Write the header byte */
bytebuffer_append_byte(child_state.header_buf, flag);
/* EXTENDED PRECISION BYTE (OPTIONAL) */
/* If needed, write the extended dim byte */
if( optional_precision_byte )
{
uint8_t flag = 0;
if ( has_z && ( globals->prec_z > 7 || globals->prec_z < 0 ) )
lwerror("%s: Z precision cannot be negative or greater than 7", __func__);
if ( has_m && ( globals->prec_m > 7 || globals->prec_m < 0 ) )
lwerror("%s: M precision cannot be negative or greater than 7", __func__);
HIGHER_DIM_SET_HASZ(flag, has_z);
HIGHER_DIM_SET_HASM(flag, has_m);
HIGHER_DIM_SET_PRECZ(flag, globals->prec_z);
HIGHER_DIM_SET_PRECM(flag, globals->prec_m);
bytebuffer_append_byte(child_state.header_buf, flag);
}
/* It the geometry is empty, we're almost done */
if ( is_empty )
{
/* If this output is sized, write the size of */
/* all following content, which is zero because */
/* there is none */
if ( globals->variant & TWKB_SIZE )
bytebuffer_append_byte(child_state.header_buf, 0);
bytebuffer_append_bytebuffer(parent_state->geom_buf, child_state.header_buf);
bytebuffer_destroy(child_state.header_buf);
bytebuffer_destroy(child_state.geom_buf);
return 0;
}
/* Write the TWKB into the output buffer */
lwgeom_to_twkb_buf(geom, globals, &child_state);
/*If we have a header_buf, we know that this function is called inside a collection*/
/*and then we have to merge the bboxes of the included geometries*/
/*and put the result to the parent (the collection)*/
if( (globals->variant & TWKB_BBOX) && parent_state->header_buf )
{
LWDEBUG(4,"Merge bboxes");
for ( i = 0; i < ndims; i++ )
{
if(child_state.bbox_min[i]<parent_state->bbox_min[i])
parent_state->bbox_min[i] = child_state.bbox_min[i];
if(child_state.bbox_max[i]>parent_state->bbox_max[i])
parent_state->bbox_max[i] = child_state.bbox_max[i];
}
}
/* Did we have a box? If so, how big? */
bbox_size = 0;
if( globals->variant & TWKB_BBOX )
{
LWDEBUG(4,"We want boxes and will calculate required size");
bbox_size = sizeof_bbox(&child_state, ndims);
}
/* Write the size if wanted */
if( globals->variant & TWKB_SIZE )
{
/* Here we have to add what we know will be written to header */
/* buffer after size value is written */
size_t size_to_register = bytebuffer_getlength(child_state.geom_buf);
size_to_register += bbox_size;
bytebuffer_append_uvarint(child_state.header_buf, size_to_register);
}
if( globals->variant & TWKB_BBOX )
write_bbox(&child_state, ndims);
bytebuffer_append_bytebuffer(parent_state->geom_buf,child_state.header_buf);
bytebuffer_append_bytebuffer(parent_state->geom_buf,child_state.geom_buf);
bytebuffer_destroy(child_state.header_buf);
bytebuffer_destroy(child_state.geom_buf);
return 0;
}
/*
* Terminate the control connection
*
* <p>
* please specify an appropriate value to result( >0 ) for
* StopCCN ResultCode AVP, when to sent Active Close (which
* require StopCCN sent).</p>
* <p>
* When the return value of this function is zero, the _this
* is already released. The lt2p_ctrl process that was bound to it
* could not contine.
* When the return value of this function is one, the timer
* is reset.</p>
*
* @return return 0 if terminate process was completed.
*/
int
l2tp_ctrl_stop(l2tp_ctrl *_this, int result)
{
int i;
l2tpd *_l2tpd;
L2TP_CTRL_ASSERT(_this != NULL);
switch (_this->state) {
case L2TP_CTRL_STATE_ESTABLISHED:
_this->state = L2TP_CTRL_STATE_CLEANUP_WAIT;
if (result > 0) {
_this->active_closing = result;
l2tp_ctrl_send_disconnect_notify(_this);
break;
}
goto cleanup;
default:
l2tp_ctrl_log(_this, LOG_DEBUG, "%s() unexpected state=%s",
__func__, l2tp_ctrl_state_string(_this));
/* FALLTHROUGH */
case L2TP_CTRL_STATE_WAIT_CTL_CONN:
/* FALLTHROUGH */
case L2TP_CTRL_STATE_CLEANUP_WAIT:
cleanup:
if (slist_length(&_this->call_list) != 0) {
if (l2tp_ctrl_disconnect_all_calls(_this, 1) > 0)
break;
}
#if 0
if (L2TP_CTRL_CONF(_this)e_ipsec_sa != 0)
l2tp_ctrl_purge_ipsec_sa(_this);
#endif
l2tp_ctrl_log(_this, LOG_NOTICE, "logtype=Finished");
evtimer_del(&_this->ev_timeout);
/* free send buffer */
if (_this->snd_buffers != NULL) {
for (i = 0; i < _this->winsz; i++)
bytebuffer_destroy(_this->snd_buffers[i]);
free(_this->snd_buffers);
_this->snd_buffers = NULL;
}
if (_this->zlb_buffer != NULL) {
bytebuffer_destroy(_this->zlb_buffer);
_this->zlb_buffer = NULL;
}
/* free l2tp_call */
l2tp_ctrl_destroy_all_calls(_this);
slist_fini(&_this->call_list);
l2tpd_remove_ctrl(_this->l2tpd, _this->tunnel_id);
_l2tpd = _this->l2tpd;
l2tp_ctrl_destroy(_this);
l2tpd_ctrl_finished_notify(_l2tpd);
return 0; /* stopped */
}
l2tp_ctrl_reset_timeout(_this);
return 1;
}
