// Create a request within a dialog
// RFC 3261 12.2.1.1
t_request *t_abstract_dialog::create_request(t_method m) {
t_user *user_config = phone_user->get_user_profile();
t_request *r = new t_request(m);
MEMMAN_NEW(r);
// To header
r->hdr_to.set_uri(remote_uri);
r->hdr_to.set_display(remote_display);
r->hdr_to.set_tag(remote_tag);
// From header
r->hdr_from.set_uri(local_uri);
r->hdr_from.set_display(local_display);
r->hdr_from.set_tag(local_tag);
// Call-ID header
r->hdr_call_id.set_call_id(call_id);
// CSeq header
r->hdr_cseq.set_method(m);
r->hdr_cseq.set_seqnr(++local_seqnr);
// Set Max-Forwards header
r->hdr_max_forwards.set_max_forwards(MAX_FORWARDS);
// User-Agent
SET_HDR_USER_AGENT(r->hdr_user_agent);
// RFC 3261 12.2.1.1
// Request URI and Route header
r->set_route(remote_target_uri, route_set);
// Caculate destination set. A DNS request can result in multiple
// IP address. In failover scenario's the request must be sent to
// the next IP address in the list. As the request will be copied
// in various places, the destination set must be calculated now.
// In previous version the DNS request was done by the transaction
// manager. This is too late as the transaction manager gets a copy
// of the request. The destination set should be set in the copy
// kept by the dialog.
r->calc_destinations(*user_config);
// The Via header can only be created after the destinations
// are calculated, because the destination deterimines which
// local IP address should be used.
// Via header
unsigned long local_ip = r->get_local_ip();
t_via via(USER_HOST(user_config, h_ip2str(local_ip)), PUBLIC_SIP_PORT(user_config));
r->hdr_via.add_via(via);
return r;
}
void t_abstract_dialog::resend_request(t_client_request *cr) {
t_user *user_config = phone_user->get_user_profile();
t_request *req = cr->get_request();
// A new sequence number must be assigned
req->hdr_cseq.set_seqnr(++local_seqnr);
// Create a new via-header. Otherwise the
// request will be seen as a retransmission
unsigned long local_ip = req->get_local_ip();
req->hdr_via.via_list.clear();
t_via via(USER_HOST(user_config, h_ip2str(local_ip)), PUBLIC_SIP_PORT(user_config));
req->hdr_via.add_via(via);
cr->renew(0);
send_request(req, cr->get_tuid());
}
void t_phone_user::resend_request(t_request *req, bool is_register, t_client_request *cr) {
// A new sequence number must be assigned
if (is_register) {
req->hdr_cseq.set_seqnr(++register_seqnr);
} else {
req->hdr_cseq.seqnr++;
}
// Create a new via-header. Otherwise the
// request will be seen as a retransmission
unsigned long local_ip = req->get_local_ip();
req->hdr_via.via_list.clear();
t_via via(USER_HOST(user_config, h_ip2str(local_ip)), PUBLIC_SIP_PORT(user_config));
req->hdr_via.add_via(via);
cr->renew(0);
phone->send_request(user_config, req, cr->get_tuid());
}
NeighborUpdater::~NeighborUpdater() {
// Stop the prober now
std::function<void()> stopProber = [=]() {
UnresolvedNhopsProber::stop(unresolvedNhopsProber_);
};
Future<Unit> f = via(sw_->getBackgroundEVB())
.then(stopProber)
.onError([=] (const std::exception& e) {
LOG (FATAL) << "Failed to stop unresolved next hops prober ";
});
// wait for prober to stop
f.get();
// reset the map of caches. This should call the destructors of
// each NeighborCache and block until everything is stopped.
caches_.clear();
}
std::unique_ptr<PNS::VIA> PNS_KICAD_IFACE::syncVia( VIA* aVia )
{
PCB_LAYER_ID top, bottom;
aVia->LayerPair( &top, &bottom );
std::unique_ptr<PNS::VIA> via( new PNS::VIA(
aVia->GetPosition(),
LAYER_RANGE( top, bottom ),
aVia->GetWidth(),
aVia->GetDrillValue(),
aVia->GetNetCode(),
aVia->GetViaType() )
);
via->SetParent( aVia );
if( aVia->IsLocked() )
via->Mark( PNS::MK_LOCKED );
return via;
}
t_request *t_phone_user::create_request(t_method m, const t_url &request_uri) const {
t_request *req = new t_request(m);
MEMMAN_NEW(req);
// From
req->hdr_from.set_uri(user_config->create_user_uri(false));
req->hdr_from.set_display(user_config->get_display(false));
req->hdr_from.set_tag(NEW_TAG);
// Max-Forwards header (mandatory)
req->hdr_max_forwards.set_max_forwards(MAX_FORWARDS);
// User-Agent
SET_HDR_USER_AGENT(req->hdr_user_agent);
// Set request URI and calculate destinations. By calculating
// destinations now, the request can be resend to a next destination
// if failover is needed.
if (m == REGISTER) {
// For a REGISTER do not use the service route for routing.
req->uri = request_uri;
} else {
// RFC 3608
// For all other requests, use the service route set for routing.
req->set_route(request_uri, service_route);
}
req->calc_destinations(*user_config);
// The Via header can only be created after the destinations
// are calculated, because the destination deterimines which
// local IP address should be used.
// Via
unsigned long local_ip = req->get_local_ip();
t_via via(USER_HOST(user_config, h_ip2str(local_ip)), PUBLIC_SIP_PORT(user_config));
req->hdr_via.add_via(via);
return req;
}
gint facet_visible(struct model_pak *data, struct plane_pak *plane)
{
gdouble a, norm[3], vec[3];
/* NEW - an edge (2 vertices) is not to be treated as visible */
if (g_slist_length(plane->vertices) < 3)
return(FALSE);
/* get plane normal */
ARR3SET(norm, plane->norm);
VEC3MUL(norm, -1.0);
#if DEBUG_FACET
printf("facet (%2d%2d%2d), norm: %5.2f,%5.2f,%5.2f "
,plane->index[0] ,plane->index[1] ,plane->index[2]
,norm[0],norm[1],norm[2]);
#endif
/* absolute viewing vector, determining if visible or not */
camera_view(vec, data->camera);
/* got correct facet normal - is it visible? */
a = via(norm,vec,3);
if (a < 0.5*G_PI)
{
#if DEBUG_FACET
printf("view: %5.2f,%5.2f,%5.2f (%5.1f) YES\n",vec[0],vec[1],vec[2],180.0*a/PI);
#endif
return(TRUE);
}
/* else... */
#if DEBUG_FACET
printf("view: %5.2f,%5.2f,%5.2f (%5.1f) NO\n",vec[0],vec[1],vec[2],180.0*a/PI);
#endif
return(FALSE);
}
void camera_waypoint_animate(gint frames, gint overwrite, struct model_pak *model)
{
gint i;
gdouble a, af, v[3], e[3], o[3], tmp[3];
gdouble jf, jv[3], x[3], mat[9];
GSList *list, *journey;
struct camera_pak *cam, *cam1, *cam2;
/* checks */
g_assert(model != NULL);
g_assert(frames > 0);
if (g_slist_length(model->waypoint_list) < 2)
{
gui_text_show(ERROR, "You need to make at least 2 waypoint.\n");
return;
}
/* close any active animation dialog */
dialog_destroy_type(ANIM);
#if DEBUG_CAMERA_ANIMATE
printf("frames for each traversal: %d\n", frames);
#endif
list = model->waypoint_list;
cam1 = list->data;
list = g_slist_next(list);
/* create the camera journey */
journey = NULL;
while (list)
{
cam2 = list->data;
/* setup camera journey vector */
ARR3SET(jv, cam2->x);
ARR3SUB(jv, cam1->x);
/* add starting camera over journey leg */
for (i=0 ; i<frames ; i++)
{
/* journey fraction */
jf = i;
jf /= frames;
ARR3SET(x, jv);
VEC3MUL(x, jf);
cam = camera_dup(cam1);
ARR3ADD(cam->x, x);
journey = g_slist_prepend(journey, cam);
}
/* approx 5 degrees */
#define ROTATION_INCREMENT 0.08727
/* (v x e plane alignment) */
proj_vop(v, cam2->v, cam1->o);
a = via(v, cam1->v, 3);
/* compute rotation increment */
af = (gint) nearest_int(a / ROTATION_INCREMENT);
if (!af)
af = 1.0;
/* test rotation sense */
matrix_v_rotation(mat, cam1->o, a);
ARR3SET(tmp, cam1->v);
vecmat(mat, tmp);
if (via(tmp, v, 3) > 0.1)
a *= -1.0;
/* build rotaton */
matrix_v_rotation(mat, cam1->o, a/af);
/* apply to camera */
ARR3SET(v, cam1->v);
ARR3SET(e, cam1->e);
for (i=af ; i-- ; )
{
cam = camera_dup(cam1);
ARR3SET(cam->x, cam2->x);
vecmat(mat, v);
vecmat(mat, e);
ARR3SET(cam->v, v);
ARR3SET(cam->e, e);
journey = g_slist_prepend(journey, cam);
}
/* TODO - apply elevation to get v in complete coincidence */
/* rotate about e to achieve coincidence */
a = via(v, cam2->v, 3);
/* compute rotation increment */
af = (gint) nearest_int(a / ROTATION_INCREMENT);
if (!af)
af = 1.0;
/* test rotation sense */
matrix_v_rotation(mat, e, a);
ARR3SET(tmp, v);
vecmat(mat, tmp);
if (via(tmp, cam2->v, 3) > 0.1)
a *= -1.0;
/* build rotaton */
matrix_v_rotation(mat, e, a/af);
/* apply to camera */
ARR3SET(o, cam1->o);
for (i=af ; i-- ; )
{
cam = camera_dup(cam1);
ARR3SET(cam->x, cam2->x);
vecmat(mat, v);
vecmat(mat, o);
ARR3SET(cam->v, v);
ARR3SET(cam->o, o);
ARR3SET(cam->e, e);
journey = g_slist_prepend(journey, cam);
}
/* endpoint camera */
journey = g_slist_prepend(journey, camera_dup(cam2));
/* get next journey leg */
cam1 = cam2;
list = g_slist_next(list);
}
journey = g_slist_reverse(journey);
if (overwrite)
{
free_slist(model->transform_list);
model->transform_list = journey;
}
else
model->transform_list = g_slist_concat(model->transform_list, journey);
model->num_frames = g_slist_length(model->transform_list);
model->animation = TRUE;
redraw_canvas(SINGLE);
}
QVariant TestItem::data(int role) const
{
switch(role) {
case DurationRole:
return duration();
case ChecksumRole:
return checksum();
case DependsRole:
return depends();
case TestNameRole:
return testname();
case RequiresRole:
return requires();
case DescriptionRole:
return description();
case CommandRole:
return command();
case EnvironRole:
return environ();
case PluginRole:
return plugin();
case TypeRole:
return type();
case UserRole:
return user();
case ViaRole:
return via();
case GroupRole:
return group();
case CheckRole:
return check();
case ObjectPathRole:
return objectpath();
case RunstatusRole:
return runstatus();
case ElapsedtimeRole:
return elapsedtime();
case GroupstatusRole:
return groupstatus();
case ParentNameRole:
break;
case ParentIdRole:
break;
case DepthRole:
return depth();
case BranchRole:
return branch();
case RerunRole:
return rerun();
default:
return QVariant();
}
// Prevents non-void return warning from the compiler
return QVariant();
}
int trans_layer::send_request(sip_msg* msg, char* tid, unsigned int& tid_len)
{
// Request-URI
// To
// From
// Call-ID
// CSeq
// Max-Forwards
// Via
// Contact
// Supported / Require
// Content-Length / Content-Type
assert(transport);
tid_len = 0;
if(set_next_hop(msg->route,msg->u.request->ruri_str,
&msg->remote_ip) < 0){
// TODO: error handling
DBG("set_next_hop failed\n");
//delete msg;
return -1;
}
// assume that msg->route headers are not in msg->hdrs
msg->hdrs.insert(msg->hdrs.begin(),msg->route.begin(),msg->route.end());
int request_len = request_line_len(msg->u.request->method_str,
msg->u.request->ruri_str);
char branch_buf[BRANCH_BUF_LEN];
compute_branch(branch_buf,msg->callid->value,msg->cseq->value);
cstring branch(branch_buf,BRANCH_BUF_LEN);
string via(transport->get_local_ip());
if(transport->get_local_port() != 5060)
via += ":" + int2str(transport->get_local_port());
request_len += via_len(stl2cstr(via),branch);
request_len += copy_hdrs_len(msg->hdrs);
string content_len = int2str(msg->body.len);
request_len += content_length_len(stl2cstr(content_len));
request_len += 2/* CRLF end-of-headers*/;
if(msg->body.len){
request_len += msg->body.len;
}
// Allocate new message
sip_msg* p_msg = new sip_msg();
p_msg->buf = new char[request_len];
p_msg->len = request_len;
// generate it
char* c = p_msg->buf;
request_line_wr(&c,msg->u.request->method_str,
msg->u.request->ruri_str);
via_wr(&c,stl2cstr(via),branch);
copy_hdrs_wr(&c,msg->hdrs);
content_length_wr(&c,stl2cstr(content_len));
*c++ = CR;
*c++ = LF;
if(msg->body.len){
memcpy(c,msg->body.s,msg->body.len);
// Not needed by now as the message is finished
//c += body.len;
}
// and parse it
if(parse_sip_msg(p_msg)){
ERROR("Parser failed on generated request\n");
ERROR("Message was: <%.*s>\n",p_msg->len,p_msg->buf);
delete p_msg;
return MALFORMED_SIP_MSG;
}
memcpy(&p_msg->remote_ip,&msg->remote_ip,sizeof(sockaddr_storage));
DBG("Sending to %s:%i <%.*s>\n",
get_addr_str(((sockaddr_in*)&p_msg->remote_ip)->sin_addr).c_str(),
ntohs(((sockaddr_in*)&p_msg->remote_ip)->sin_port),
p_msg->len,p_msg->buf);
trans_bucket* bucket = get_trans_bucket(p_msg->callid->value,
get_cseq(p_msg)->num_str);
bucket->lock();
int send_err = transport->send(&p_msg->remote_ip,p_msg->buf,p_msg->len);
if(send_err < 0){
ERROR("Error from transport layer\n");
delete p_msg;
}
else {
sip_trans* t = bucket->add_trans(p_msg,TT_UAC);
if(p_msg->u.request->method == sip_request::INVITE){
// if transport == UDP
t->reset_timer(STIMER_A,A_TIMER,bucket->get_id());
// for any transport type
t->reset_timer(STIMER_B,B_TIMER,bucket->get_id());
}
else {
// if transport == UDP
t->reset_timer(STIMER_E,E_TIMER,bucket->get_id());
// for any transport type
t->reset_timer(STIMER_F,F_TIMER,bucket->get_id());
}
string t_id = int2hex(bucket->get_id()).substr(5,string::npos)
+ ":" + long2hex((unsigned long)t);
memcpy(tid,t_id.c_str(),t_id.length());
tid_len = t_id.length();
}
bucket->unlock();
return send_err;
}
bool CDplusProtocol::OnDvHeaderPacketIn(CDvHeaderPacket *Header, const CIp &Ip)
{
bool newstream = false;
// find the stream
CPacketStream *stream = GetStream(Header->GetStreamId());
if ( stream == NULL )
{
// no stream open yet, open a new one
CCallsign via(Header->GetRpt1Callsign());
// first, check module is valid
if ( g_Reflector.IsValidModule(Header->GetRpt1Module()) )
{
// find this client
CClient *client = g_Reflector.GetClients()->FindClient(Ip, PROTOCOL_DPLUS);
if ( client != NULL )
{
// now we know if it's a dextra dongle or a genuine dplus node
if ( Header->GetRpt2Callsign().HasSameCallsignWithWildcard(CCallsign("XRF*")) )
{
client->SetDextraDongle();
}
// now we know its module, let's update it
if ( !client->HasModule() )
{
client->SetModule(Header->GetRpt1Module());
}
// get client callsign
via = client->GetCallsign();
// and try to open the stream
if ( (stream = g_Reflector.OpenStream(Header, client)) != NULL )
{
// keep the handle
m_Streams.push_back(stream);
newstream = true;
}
}
// release
g_Reflector.ReleaseClients();
// update last heard
g_Reflector.GetUsers()->Hearing(Header->GetMyCallsign(), via, Header->GetRpt2Callsign());
g_Reflector.ReleaseUsers();
}
else
{
std::cout << "DPlus node " << via << " link attempt on non-existing module" << std::endl;
}
}
else
{
// stream already open
// skip packet, but tickle the stream
stream->Tickle();
// and delete packet
delete Header;
}
// done
return newstream;
}
/*
* Distributed sorting.
*
* Performs the sorting by breaking the list into chunks, sending requests out
* to each backend server to sort 1 chunk, then merging the results.
*
* Sorting a list of size N normally requires O(N log N) time.
* Distributing the sorting operation over M servers requires
* O(N/M log N/M) time on each server (performed in parallel), plus
* O(N log M) time to merge the sorted lists back together.
*
* (In reality, the extra I/O overhead of copying the data and sending it out
* to the servers probably makes it not worthwhile for most use cases.
* However, it provides a relatively easy-to-understand example.)
*/
Future<vector<int32_t>> SortDistributorHandler::future_sort(
const vector<int32_t>& values) {
// If there's just one value, go ahead and return it now.
// (This avoids infinite recursion if we happen to be pointing at ourself as
// one of the backend servers.)
if (values.size() <= 1) {
return makeFuture(values);
}
// Perform the sort by breaking the list into pieces,
// and farming them out the the servers we know about.
size_t chunk_size = values.size() / backends_.size();
// Round up the chunk size when it is not integral
if (values.size() % backends_.size() != 0) {
chunk_size += 1;
}
auto tm = getThreadManager();
auto eb = getEventBase();
// Create futures for all the requests to the backends, and when they all
// complete.
return collectAll(
gen::range<size_t>(0, backends_.size())
| gen::map([&](size_t idx) {
// Chunk it.
auto a = chunk_size * idx;
auto b = chunk_size * (idx + 1);
vector<int32_t> chunk(
values.begin() + a,
values.begin() + std::min(values.size(), b));
// Issue a request from the IO thread for each chunk.
auto chunkm = makeMoveWrapper(move(chunk));
return via(eb, [=]() mutable {
auto chunk = chunkm.move();
auto client = make_unique<SorterAsyncClient>(
HeaderClientChannel::newChannel(
async::TAsyncSocket::newSocket(
eb, backends_.at(idx))));
return client->future_sort(chunk);
});
})
| gen::as<vector>())
// Back in a CPU thread, when al the results are in.
.via(tm)
.then([=](vector<Try<vector<int32_t>>> xresults) {
// Throw if any of the backends threw.
auto results = gen::from(xresults)
| gen::map([](Try<vector<int32_t>> xresult) {
return move(xresult.value());
})
| gen::as<vector>();
// Build a heap containing one Range for each of the response vectors.
// The Range starting with the smallest value is kept on top.
using it = vector<int32_t>::const_iterator;
struct it_range_cmp {
bool operator()(Range<it> a, Range<it> b) {
return a.front() > b.front();
}
};
priority_queue<Range<it>, vector<Range<it>>, it_range_cmp> heap;
for (auto& result : results) {
if (result.empty()) {
continue;
}
heap.push(Range<it>(result.begin(), result.end()));
}
// Cycle through the heap, merging the sorted chunks back into one list.
// On each iteration:
// * Pull out the Range with the least first element (each Range is pre-
// sorted).
// * Pull out that first element and add it to the merged result.
// * Put the Range back without that first element, if it is non-empty.
vector<int32_t> merged;
while (!heap.empty()) {
auto v = heap.top();
heap.pop();
merged.push_back(v.front());
v.advance(1);
if (!v.empty()) {
heap.push(v);
}
}
return merged;
});
}
void zmat_build(void)
{
gint i, j, k, n, type;
gdouble r, a, d, x[4][3], v[3];
gdouble zaxis[3] = {0.0, 0.0, 1.0};
gchar *line;
GSList *list, *species;
struct zmat_pak *zmat;
struct core_pak *core[4] = {NULL, NULL, NULL, NULL};
struct model_pak *model;
model = sysenv.active_model;
if (!model)
return;
/* CURRENT - using selection as our list of cores to generate a zmatrix from */
if (!model->selection)
{
gui_text_show(WARNING, "ZMATRIX: please select a molecule.\n");
return;
}
/* destroy old zmatrix */
/* TODO - prompt if non null */
zmat_free(model->zmatrix);
zmat = model->zmatrix = zmat_new();
zmat_angle_units_set(model->zmatrix, DEGREES);
/* setup SIESTA species type */
species = fdf_species_build(model);
/* sort the list so it follows molecular connectivity */
model->selection = zmat_connect_sort(model->selection);
n=0;
for (list=model->selection ; list ; list=g_slist_next(list))
{
/* current atom/zmatrix line init */
core[0] = list->data;
type = fdf_species_index(core[0]->atom_label, species);
line = NULL;
zmat->zcores = g_slist_append(zmat->zcores, core[0]);
/* build a ZMATRIX line for processing */
switch (n)
{
case 0:
if (core[0])
{
ARR3SET(x[0], core[0]->x);
vecmat(model->latmat, x[0]);
}
line = g_strdup_printf("%d 0 0 0 %f %f %f 0 0 0\n", type, x[0][0], x[0][1], x[0][2]);
break;
case 1:
if (core[0])
{
ARR3SET(x[0], core[0]->x);
vecmat(model->latmat, x[0]);
}
if (core[1])
{
ARR3SET(x[1], core[1]->x);
vecmat(model->latmat, x[1]);
}
r = measure_distance(x[0], x[1]);
/* angle with z axis */
ARR3SET(v, x[0]);
ARR3SUB(v, x[1]);
a = R2D * via(v, zaxis, 3);
/* angle between xy projection and x axis */
d = R2D * angle_x_compute(v[0], v[1]);
line = g_strdup_printf("%d 1 0 0 %f %f %f 0 0 0\n", type, r, a, d);
break;
case 2:
/* coords init */
for (i=3 ; i-- ; )
{
if (core[i])
{
ARR3SET(x[i], core[i]->x);
vecmat(model->latmat, x[i]);
}
else
g_assert_not_reached();
}
r = measure_distance(x[0], x[1]);
a = measure_angle(x[0], x[1], x[2]);
/* create a fake core -> 1 unit displaced in the z direction */
g_assert(core[3] == NULL);
core[3] = core_new("x", NULL, model);
ARR3SET(core[3]->rx, core[2]->rx);
ARR3ADD(core[3]->rx, zaxis);
d = measure_torsion(core);
core_free(core[3]);
line = g_strdup_printf("%d 2 1 0 %f %f %f 0 0 0\n", type,r,a,d);
break;
default:
/* connectivity test */
if (!zmat_bond_check(core[0], core[1]))
{
#if DEBUG_ZMAT_BUILD
printf("[%d] non-connected atoms [%f]\n", n, measure_distance(x[0], x[1]));
#endif
/* need to build a new connectivity chain starting from core[0] */
core[1] = core[2] = core[3] = NULL;
if (!zmat_connect_find(n, core, zmat))
{
gui_text_show(WARNING, "ZMATRIX: bad connectivity (molecule will be incomplete)\n");
goto zmat_build_done;
}
}
/* coords init */
for (i=3 ; i-- ; )
{
if (core[i])
{
ARR3SET(x[i], core[i]->x);
vecmat(model->latmat, x[i]);
}
else
g_assert_not_reached();
}
r = measure_distance(x[0], x[1]);
a = measure_angle(x[0], x[1], x[2]);
d = measure_torsion(core);
/* NB: indexing starts from 0, siesta starts from 1 (naturally) */
i = 1+g_slist_index(zmat->zcores, core[1]);
j = 1+g_slist_index(zmat->zcores, core[2]);
k = 1+g_slist_index(zmat->zcores, core[3]);
line = g_strdup_printf("%d %d %d %d %f %f %f 0 0 0\n", type,i,j,k,r,a,d);
}
/* process a successfully constructed ZMATRIX line */
if (line)
{
zmat_core_add(line, model->zmatrix);
g_free(line);
}
/* shuffle */
core[3] = core[2];
core[2] = core[1];
core[1] = core[0];
n++;
}
zmat_build_done:
/* do the species typing */
zmat_type(model->zmatrix, species);
free_slist(species);
}
int trans_layer::cancel(trans_bucket* bucket, sip_trans* t)
{
bucket->lock();
if(!bucket->exist(t)){
DBG("No transaction to cancel: wrong key or finally replied\n");
bucket->unlock();
return 0;
}
sip_msg* req = t->msg;
// RFC 3261 says: SHOULD NOT be sent for other request
// than INVITE.
if(req->u.request->method != sip_request::INVITE){
bucket->unlock();
ERROR("Trying to cancel a non-INVITE request (we SHOULD NOT do that)\n");
return -1;
}
switch(t->state){
case TS_CALLING:
// do not send a request:
// just remove the transaction
bucket->remove_trans(t);
bucket->unlock();
return 0;
case TS_COMPLETED:
// final reply has been sent:
// do nothing!!!
bucket->unlock();
return 0;
case TS_PROCEEDING:
// continue with CANCEL request
break;
}
cstring cancel_str("CANCEL");
int request_len = request_line_len(cancel_str,
req->u.request->ruri_str);
char branch_buf[BRANCH_BUF_LEN];
compute_branch(branch_buf,req->callid->value,get_cseq(req)->num_str);
cstring branch(branch_buf,BRANCH_BUF_LEN);
string via(transport->get_local_ip());
if(transport->get_local_port() != 5060)
via += ":" + int2str(transport->get_local_port());
request_len += copy_hdr_len(req->via1);
request_len += copy_hdr_len(req->to)
+ copy_hdr_len(req->from)
+ copy_hdr_len(req->callid)
+ cseq_len(get_cseq(req)->num_str,cancel_str)
+ copy_hdrs_len(req->route)
+ copy_hdrs_len(req->contacts);
request_len += 2/* CRLF end-of-headers*/;
// Allocate new message
sip_msg* p_msg = new sip_msg();
p_msg->buf = new char[request_len];
p_msg->len = request_len;
// generate it
char* c = p_msg->buf;
request_line_wr(&c,cancel_str,
req->u.request->ruri_str);
copy_hdr_wr(&c,req->via1);
copy_hdr_wr(&c,req->to);
copy_hdr_wr(&c,req->from);
copy_hdr_wr(&c,req->callid);
cseq_wr(&c,get_cseq(req)->num_str,cancel_str);
copy_hdrs_wr(&c,req->route);
copy_hdrs_wr(&c,req->contacts);
*c++ = CR;
*c++ = LF;
// and parse it
if(parse_sip_msg(p_msg)){
ERROR("Parser failed on generated request\n");
ERROR("Message was: <%.*s>\n",p_msg->len,p_msg->buf);
delete p_msg;
return MALFORMED_SIP_MSG;
}
memcpy(&p_msg->remote_ip,&req->remote_ip,sizeof(sockaddr_storage));
DBG("Sending to %s:%i <%.*s>\n",
get_addr_str(((sockaddr_in*)&p_msg->remote_ip)->sin_addr).c_str(),
ntohs(((sockaddr_in*)&p_msg->remote_ip)->sin_port),
p_msg->len,p_msg->buf);
int send_err = transport->send(&p_msg->remote_ip,p_msg->buf,p_msg->len);
if(send_err < 0){
ERROR("Error from transport layer\n");
delete p_msg;
}
else {
trans_bucket* n_bucket = get_trans_bucket(p_msg->callid->value,
get_cseq(p_msg)->num_str);
if(bucket != n_bucket)
n_bucket->lock();
sip_trans* t = n_bucket->add_trans(p_msg,TT_UAC);
// if transport == UDP
t->reset_timer(STIMER_E,E_TIMER,bucket->get_id());
// for any transport type
t->reset_timer(STIMER_F,F_TIMER,bucket->get_id());
if(bucket != n_bucket)
n_bucket->unlock();
}
bucket->unlock();
return send_err;
}
static int test_vector_op()
{
vector <vector<int>> vvec1, vvec2;
vvec2 = vvec1;
vector <string> articles{1, "ab"}; //10不能用来初始化string，所以当做成员个数，结果是10个"ab"
string s;
// while (cin >> s) {
// articles.push_back(s);
// }
for(auto s : articles)
std::cout << s << endl;
auto it_b = articles.begin();
auto it_e = articles.end();
string s2("some string");
for (auto it = s2.begin(); it != s2.end() && !isspace(*it); ++it) {
*it = toupper(*it);
}
cout << s2 << endl;
const char a4[6]{"abcde"};
cout <<a4 << endl;
int ia[3] = {1, 2, 3};
decltype(ia) ia2{ 4, 5 };
ia2[0] = 6;
auto pia = ia;
int *beg = std::begin(ia); //begin end 函数
int *e2 = std::end(ia);
auto diff = e2 - beg;
vector<int> via(std::begin(ia), std::end(ia));
vector<int> via2(ia, ia+sizeof(ia)/sizeof(*ia));
vector<int> via3 = {std::begin(ia), std::end(ia)};
for(auto i : via3)
std::cout << i << endl;
int m_array[3][4];
int m_cnt = 0;
for (auto &row : m_array) {
for (auto &col : row) {
col = m_cnt;
m_cnt++;
}
}
for (auto &row : m_array) {
for (auto &col : row) {
cout << col << ' ';
}
cout << endl;
}
decltype(&m_cnt) p = 0; //&取地址符返回右值
return 0;
}
void econet_e01_device::device_add_mconfig(machine_config &config)
{
// basic machine hardware
M65C02(config, m_maincpu, XTAL(8'000'000)/4); // Rockwell R65C102P3
m_maincpu->set_addrmap(AS_PROGRAM, &econet_e01_device::e01_mem);
MC146818(config, m_rtc, 32.768_kHz_XTAL);
m_rtc->irq().set(FUNC(econet_e01_device::rtc_irq_w));
// devices
via6522_device &via(VIA6522(config, R6522_TAG, 8_MHz_XTAL / 4));
via.writepa_handler().set("cent_data_out", FUNC(output_latch_device::bus_w));
via.irq_handler().set(FUNC(econet_e01_device::via_irq_w));
MC6854(config, m_adlc, 0);
m_adlc->out_irq_cb().set(FUNC(econet_e01_device::adlc_irq_w));
m_adlc->out_txd_cb().set(FUNC(econet_e01_device::econet_data_w));
WD2793(config, m_fdc, 8_MHz_XTAL / 4);
m_fdc->intrq_wr_callback().set(FUNC(econet_e01_device::fdc_irq_w));
m_fdc->drq_wr_callback().set(FUNC(econet_e01_device::fdc_drq_w));
for (int i = 0; i < 2; i++)
{
FLOPPY_CONNECTOR(config, m_floppy[i]);
m_floppy[i]->option_add("35dd", FLOPPY_35_DD);
m_floppy[i]->set_default_option("35dd");
m_floppy[i]->set_formats(floppy_formats_afs);
}
software_list_device &softlist(SOFTWARE_LIST(config, "flop_ls_e01"));
softlist.set_type("e01_flop", SOFTWARE_LIST_ORIGINAL_SYSTEM);
CENTRONICS(config, m_centronics, centronics_devices, "printer");
m_centronics->ack_handler().set(R6522_TAG, FUNC(via6522_device::write_ca1));
output_latch_device ¢_data_out(OUTPUT_LATCH(config, "cent_data_out"));
m_centronics->set_output_latch(cent_data_out);
SCSI_PORT(config, m_scsibus);
m_scsibus->set_data_input_buffer(m_scsi_data_in);
m_scsibus->msg_handler().set(m_scsi_ctrl_in, FUNC(input_buffer_device::write_bit0));
m_scsibus->bsy_handler().set(FUNC(econet_e01_device::scsi_bsy_w)); // bit1
// bit 2 0
// bit 3 0
// bit 4 NIRQ
m_scsibus->req_handler().set(FUNC(econet_e01_device::scsi_req_w)); // bit5
m_scsibus->io_handler().set(m_scsi_ctrl_in, FUNC(input_buffer_device::write_bit6));
m_scsibus->cd_handler().set(m_scsi_ctrl_in, FUNC(input_buffer_device::write_bit7));
m_scsibus->set_slot_device(1, "harddisk", SCSIHD, DEVICE_INPUT_DEFAULTS_NAME(SCSI_ID_0));
OUTPUT_LATCH(config, m_scsi_data_out);
m_scsibus->set_output_latch(*m_scsi_data_out);
INPUT_BUFFER(config, m_scsi_data_in);
INPUT_BUFFER(config, m_scsi_ctrl_in);
// internal ram
RAM(config, m_ram);
m_ram->set_default_size("64K");
}
void trans_layer::send_200_ack(sip_msg* reply, sip_trans* t)
{
// Set request URI
// TODO: use correct R-URI instead of just 'Contact'
if(!get_contact(reply)) {
DBG("Sorry, reply has no Contact header: could not send ACK\n");
return;
}
sip_nameaddr na;
const char* c = get_contact(reply)->value.s;
if(parse_nameaddr(&na,&c,get_contact(reply)->value.len) < 0){
DBG("Sorry, reply's Contact parsing failed: could not send ACK\n");
return;
}
cstring r_uri = na.addr;
list<sip_header*> route_hdrs;
if(t && !t->msg->route.empty()){
for(list<sip_header*>::iterator it = t->msg->route.begin();
it != t->msg->route.end(); ++it) {
route_hdrs.push_back(new sip_header(0,"Route",(*it)->value));
}
}
else {
for(list<sip_header*>::reverse_iterator it = reply->record_route.rbegin();
it != reply->record_route.rend(); ++it) {
route_hdrs.push_back(new sip_header(0,"Route",(*it)->value));
}
}
sockaddr_storage remote_ip;
set_next_hop(route_hdrs,r_uri,&remote_ip);
int request_len = request_line_len(cstring("ACK",3),r_uri);
char branch_buf[BRANCH_BUF_LEN];
compute_branch(branch_buf,reply->callid->value,reply->cseq->value);
cstring branch(branch_buf,BRANCH_BUF_LEN);
sip_header* max_forward = new sip_header(0,cstring("Max-Forwards"),cstring("10"));
cstring via((char*)transport->get_local_ip());
request_len += via_len(via,branch);
request_len += copy_hdrs_len(route_hdrs);
request_len += copy_hdr_len(reply->to);
request_len += copy_hdr_len(reply->from);
request_len += copy_hdr_len(reply->callid);
request_len += copy_hdr_len(max_forward);
request_len += cseq_len(get_cseq(reply)->num_str,cstring("ACK",3));
request_len += 2/* CRLF end-of-headers*/;
// Allocate new message
char* ack_buf = new char[request_len];
// generate it
char* msg = ack_buf;
request_line_wr(&msg,cstring("ACK",3),r_uri);
via_wr(&msg,via,branch);
copy_hdrs_wr(&msg,route_hdrs);
// clear route headers list
for (list<sip_header*>::iterator it=route_hdrs.begin();
it!= route_hdrs.end(); it++)
delete *it;
copy_hdr_wr(&msg,reply->from);
copy_hdr_wr(&msg,reply->to);
copy_hdr_wr(&msg,reply->callid);
copy_hdr_wr(&msg,max_forward);
delete max_forward;
cseq_wr(&msg,get_cseq(reply)->num_str,cstring("ACK",3));
*msg++ = CR;
*msg++ = LF;
DBG("About to send 200 ACK\n");
// DBG("About to send 200 ACK: \n<%.*s>\n",request_len,ack_buf);
assert(transport);
int send_err = transport->send(&remote_ip,ack_buf,request_len);
if(send_err < 0){
ERROR("Error from transport layer\n");
delete [] ack_buf;
}
else if(t){
delete [] t->retr_buf;
t->retr_buf = ack_buf;
t->retr_len = request_len;
memcpy(&t->retr_addr,&remote_ip,sizeof(sockaddr_storage));
}
}
