My Project
Loading...
Searching...
No Matches
Functions
ssiLink.h File Reference
#include "Singular/links/silink.h"

Go to the source code of this file.

Functions

BOOLEAN ssiOpen (si_link l, short flag, leftv u)
 
BOOLEAN ssiWrite (si_link l, leftv v)
 
leftv ssiRead1 (si_link l)
 
leftv ssiRead2 (si_link l, leftv key)
 
BOOLEAN ssiClose (si_link l)
 
const charslStatusSsi (si_link l, const char *request)
 
si_link_extension slInitSsiExtension (si_link_extension s)
 
si_link ssiCommandLink ()
 
void sig_chld_hdl (int sig)
 additional default signal handler
 
int ssiReservePort (int clients)
 

Function Documentation

◆ sig_chld_hdl()

void sig_chld_hdl ( int  sig)

additional default signal handler

some newer Linux version cannot have SIG_IGN for SIGCHLD, so use this nice routine here: SuSe 9.x reports -1 always Redhat 9.x/FC x reports sometimes -1 see also: hpux_system also needed by getrusage (timer etc.)

Parameters
[in]sig

Definition at line 2319 of file ssiLink.cc.

2320{
2321 pid_t kidpid;
2322 int status;
2323
2324 loop
2325 {
2327 if (kidpid==-1)
2328 {
2329 /* continue on interruption (EINTR): */
2330 if (errno == EINTR) continue;
2331 /* break on anything else (EINVAL or ECHILD according to manpage): */
2332 break;
2333 }
2334 else if (kidpid==0) break; /* no more children to process, so break */
2335
2336 //printf("Child %ld terminated\n", kidpid);
2338 while((hh!=NULL)&&(ssiToBeClosed_inactive))
2339 {
2340 if((hh->l!=NULL) && (hh->l->m->Open==ssiOpen))
2341 {
2342 ssiInfo *d = (ssiInfo *)hh->l->data;
2343 if(d->pid==kidpid)
2344 {
2346 {
2348 slClose(hh->l);
2350 break;
2351 }
2352 else break;
2353 }
2354 else hh=(link_list)hh->next;
2355 }
2356 else hh=(link_list)hh->next;
2357 }
2358 }
2359}
#define TRUE
Definition auxiliary.h:100
#define FALSE
Definition auxiliary.h:96
#define NULL
Definition omList.c:12
int * status
Definition si_signals.h:61
#define loop
Definition structs.h:75

◆ slInitSsiExtension()

si_link_extension slInitSsiExtension ( si_link_extension  s)

Definition at line 1879 of file ssiLink.cc.

1880{
1881 s->Open=ssiOpen;
1882 s->Close=ssiClose;
1883 s->Kill=ssiClose;
1884 s->Read=ssiRead1;
1885 s->Read2=(slRead2Proc)NULL;
1886 s->Write=ssiWrite;
1887 s->Dump=ssiDump;
1888 s->GetDump=ssiGetDump;
1889
1890 s->Status=slStatusSsi;
1891 s->SetRing=ssiSetRing;
1892 s->type="ssi";
1893 return s;
1894}
const CanonicalForm int s
Definition facAbsFact.cc:51

◆ slStatusSsi()

const char * slStatusSsi ( si_link  l,
const char request 
)

Definition at line 1896 of file ssiLink.cc.

1897{
1898 ssiInfo *d=(ssiInfo*)l->data;
1899 if (d==NULL) return "not open";
1900 if (((strcmp(l->mode,"fork")==0)
1901 ||(strcmp(l->mode,"tcp")==0)
1902 ||(strcmp(l->mode,"connect")==0))
1903 && (strcmp(request, "read") == 0))
1904 {
1905 if (s_isready(d->f_read)) return "ready";
1906#if defined(HAVE_POLL)
1907 pollfd pfd;
1908 loop
1909 {
1910 /* Don't block. Return socket status immediately. */
1911 pfd.fd=d->fd_read;
1912 pfd.events=POLLIN;
1913 //Print("test fd %d\n",d->fd_read);
1914 /* check with select: chars waiting: no -> not ready */
1915 switch (si_poll(&pfd,1,0))
1916 {
1917 case 0: /* not ready */ return "not ready";
1918 case -1: /*error*/ return "error";
1919 case 1: /*ready ? */ break;
1920 }
1921#else
1922 fd_set mask;
1923 struct timeval wt;
1924 if (FD_SETSIZE<=d->fd_read)
1925 {
1926 Werror("file descriptor number too high (%d)",d->fd_read);
1927 return "error";
1928 }
1929
1930 loop
1931 {
1932 /* Don't block. Return socket status immediately. */
1933 wt.tv_sec = 0;
1934 wt.tv_usec = 0;
1935
1936 FD_ZERO(&mask);
1937 FD_SET(d->fd_read, &mask);
1938 //Print("test fd %d\n",d->fd_read);
1939 /* check with select: chars waiting: no -> not ready */
1940 switch (si_select(d->fd_read+1, &mask, NULL, NULL, &wt))
1941 {
1942 case 0: /* not ready */ return "not ready";
1943 case -1: /*error*/ return "error";
1944 case 1: /*ready ? */ break;
1945 }
1946#endif
1947 /* yes: read 1 char*/
1948 /* if \n, check again with select else ungetc(c), ready*/
1949 int c=s_getc(d->f_read);
1950 //Print("try c=%d\n",c);
1951 if (c== -1) return "eof"; /* eof or error */
1952 else if (isdigit(c))
1953 { s_ungetc(c,d->f_read); return "ready"; }
1954 else if (c>' ')
1955 {
1956 Werror("unknown char in ssiLink(%d)",c);
1957 return "error";
1958 }
1959 /* else: next char */
1960 }
1961 }
1962 else if (strcmp(request, "read") == 0)
1963 {
1964 if (SI_LINK_R_OPEN_P(l) && (!s_iseof(d->f_read)) && (s_isready(d->f_read))) return "ready";
1965 else return "not ready";
1966 }
1967 else if (strcmp(request, "write") == 0)
1968 {
1969 if (SI_LINK_W_OPEN_P(l)) return "ready";
1970 else return "not ready";
1971 }
1972 else return "unknown status request";
1973}
int l
Definition cfEzgcd.cc:100
void Werror(const char *fmt,...)
Definition reporter.cc:189
int s_getc(s_buff F)
Definition s_buff.cc:58
int s_isready(s_buff F)
Definition s_buff.cc:85
int s_iseof(s_buff F)
Definition s_buff.cc:254
void s_ungetc(int c, s_buff F)
Definition s_buff.cc:99

◆ ssiClose()

BOOLEAN ssiClose ( si_link  l)

Definition at line 1429 of file ssiLink.cc.

1430{
1431 if (l!=NULL)
1432 {
1434 ssiInfo *d = (ssiInfo *)l->data;
1435 if (d!=NULL)
1436 {
1437 // send quit signal
1438 if ((d->send_quit_at_exit)
1439 && (d->quit_sent==0))
1440 {
1441 fputs("99\n",d->f_write);
1442 fflush(d->f_write);
1443 }
1444 // clean ring
1445 if (d->r!=NULL) rKill(d->r);
1446 for(int i=0;i<SI_RING_CACHE;i++)
1447 {
1448 if (d->rings[i]!=NULL) rKill(d->rings[i]);
1449 d->rings[i]=NULL;
1450 }
1451 // did the child to stop ?
1452 si_waitpid(d->pid,NULL,WNOHANG);
1453 if ((d->pid!=0)
1454 && (kill(d->pid,0)==0)) // child is still running
1455 {
1456 struct timespec t;
1457 t.tv_sec=0;
1458 t.tv_nsec=100000000; // <=100 ms
1459 struct timespec rem;
1460 int r;
1461 loop
1462 {
1463 // wait till signal or time rem:
1464 r = nanosleep(&t, &rem);
1465 t = rem;
1466 // child finished:
1467 if (si_waitpid(d->pid,NULL,WNOHANG) != 0) break;
1468 // other signal, waited s>= 100 ms:
1469 if ((r==0) || (errno != EINTR)) break;
1470 }
1471 if (kill(d->pid,0) == 0) // pid still exists
1472 {
1473 kill(d->pid,15);
1474 t.tv_sec=5; // <=5s
1475 t.tv_nsec=0;
1476 loop
1477 {
1478 // wait till signal or time rem:
1479 r = nanosleep(&t, &rem);
1480 t = rem;
1481 // child finished:
1482 if (si_waitpid(d->pid,NULL,WNOHANG) != 0) break;
1483 // other signal, waited s>= 5 s:
1484 if ((r==0) || (errno != EINTR)) break;
1485 }
1486 if (kill(d->pid,0) == 0)
1487 {
1488 kill(d->pid,9); // just to be sure
1489 si_waitpid(d->pid,NULL,0);
1490 }
1491 }
1492 }
1493 if (d->f_read!=NULL) { s_close(d->f_read);d->f_read=NULL;}
1494 if (d->f_write!=NULL) { fclose(d->f_write); d->f_write=NULL; }
1495 if ((strcmp(l->mode,"tcp")==0)
1496 || (strcmp(l->mode,"fork")==0))
1497 {
1499 if (hh!=NULL)
1500 {
1501 if (hh->l==l)
1502 {
1503 ssiToBeClosed=(link_list)hh->next;
1504 omFreeSize(hh,sizeof(link_struct));
1505 }
1506 else while(hh->next!=NULL)
1507 {
1508 link_list hhh=(link_list)hh->next;
1509 if (hhh->l==l)
1510 {
1511 hh->next=hhh->next;
1512 omFreeSize(hhh,sizeof(link_struct));
1513 break;
1514 }
1515 else
1516 hh=(link_list)hh->next;
1517 }
1518 }
1519 }
1520 omFreeSize((ADDRESS)d,(sizeof *d));
1521 }
1522 l->data=NULL;
1523 }
1524 return FALSE;
1525}
int i
Definition cfEzgcd.cc:132
void rKill(ring r)
Definition ipshell.cc:6173
void rem(unsigned long *a, unsigned long *q, unsigned long p, int &dega, int degq)
Definition minpoly.cc:572
#define omFreeSize(addr, size)
int s_close(s_buff &F)
Definition s_buff.cc:45
#define SI_RING_CACHE
Definition s_buff.h:30

◆ ssiCommandLink()

si_link ssiCommandLink ( )

Definition at line 2248 of file ssiLink.cc.

2249{
2250 if (ssiReserved_P==0)
2251 {
2252 WerrorS("ERROR no reserved port requested");
2253 return NULL;
2254 }
2255 struct sockaddr_in cli_addr;
2256 int clilen = sizeof(cli_addr);
2258 if(newsockfd < 0)
2259 {
2260 Werror("ERROR on accept (errno=%d)",errno);
2261 return NULL;
2262 }
2265 si_link_extension prev = s;
2266 while (strcmp(s->type, "ssi") != 0)
2267 {
2268 if (s->next == NULL)
2269 {
2270 prev = s;
2271 s = NULL;
2272 break;
2273 }
2274 else
2275 {
2276 s = s->next;
2277 }
2278 }
2279 if (s != NULL)
2280 l->m = s;
2281 else
2282 {
2284 prev->next=slInitSsiExtension(ns);
2285 l->m = prev->next;
2286 }
2287 l->name=omStrDup("");
2288 l->mode=omStrDup("tcp");
2289 l->ref=1;
2290 ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
2291 l->data=d;
2292 d->fd_read = newsockfd;
2293 d->fd_write = newsockfd;
2294 d->f_read = s_open(newsockfd);
2295 d->f_write = fdopen(newsockfd, "w");
2298 if (ssiReserved_Clients<=0)
2299 {
2300 ssiReserved_P=0;
2302 }
2303 return l;
2304}
void WerrorS(const char *s)
Definition feFopen.cc:24
#define omStrDup(s)
#define omAlloc0Bin(bin)
#define omAlloc0(size)
s_buff s_open(int fd)
Definition s_buff.cc:31
int fd_write
Definition s_buff.h:26
s_buff f_read
Definition s_buff.h:22
FILE * f_write
Definition s_buff.h:23
int fd_read
Definition s_buff.h:26

◆ ssiOpen()

BOOLEAN ssiOpen ( si_link  l,
short  flag,
leftv  u 
)

Definition at line 998 of file ssiLink.cc.

999{
1000 if (l!=NULL)
1001 {
1002 const char *mode;
1003 ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
1004 if (flag & SI_LINK_OPEN)
1005 {
1006 if (l->mode[0] != '\0' && (strcmp(l->mode, "r") == 0))
1007 flag = SI_LINK_READ;
1008 else flag = SI_LINK_WRITE;
1009 }
1010
1011 if (flag == SI_LINK_READ) mode = "r";
1012 else if (strcmp(l->mode, "w") == 0) mode = "w";
1013 else if (strcmp(l->mode, "fork") == 0) mode = "fork";
1014 else if (strcmp(l->mode, "tcp") == 0) mode = "tcp";
1015 else if (strcmp(l->mode, "connect") == 0) mode = "connect";
1016 else mode = "a";
1017
1018
1019 SI_LINK_SET_OPEN_P(l, flag);
1020 if(l->data!=NULL) omFreeSize(l->data,sizeof(ssiInfo));
1021 l->data=d;
1022 omFreeBinAddr(l->mode);
1023 l->mode = omStrDup(mode);
1024
1025 if (l->name[0] == '\0')
1026 {
1027 if (strcmp(mode,"fork")==0)
1028 {
1029 int pc[2];
1030 int cp[2];
1031 int err1=pipe(pc);
1032 int err2=pipe(cp);
1033 if (err1 || err2)
1034 {
1035 Werror("pipe failed with %d\n",errno);
1036 return TRUE;
1037 }
1039 n->u=u;
1040 n->l=l;
1041 n->next=(void *)ssiToBeClosed;
1042 ssiToBeClosed=n;
1043
1044 pid_t pid = fork();
1045 if (pid == -1 && errno == EAGAIN) // RLIMIT_NPROC too low?
1046 {
1048 pid = fork();
1049 }
1050 if (pid == -1)
1051 {
1052 WerrorS("could not fork");
1053 }
1054 if (pid==0) /*fork: child*/
1055 {
1056 /* block SIGINT */
1061 /* set #cpu to 1 for the child:*/
1063
1065 /* we know: l is the first entry in ssiToBeClosed-list */
1066 while(hh!=NULL)
1067 {
1069 ssiInfo *dd=(ssiInfo*)hh->l->data;
1070 s_close(dd->f_read);
1071 fclose(dd->f_write);
1072 if (dd->r!=NULL) rKill(dd->r);
1073 omFreeSize((ADDRESS)dd,(sizeof *dd));
1074 hh->l->data=NULL;
1075 link_list nn=(link_list)hh->next;
1076 omFree(hh);
1077 hh=nn;
1078 }
1080#ifdef HAVE_SIMPLEIPC
1082#endif // HAVE_SIMPLEIPC
1083 si_close(pc[1]); si_close(cp[0]);
1084 d->f_write=fdopen(cp[1],"w");
1085 d->f_read=s_open(pc[0]);
1086 d->fd_read=pc[0];
1087 d->fd_write=cp[1];
1088 //d->r=currRing;
1089 //if (d->r!=NULL) d->r->ref++;
1090 l->data=d;
1091 omFreeBinAddr(l->mode);
1092 l->mode = omStrDup(mode);
1095 //myynest=0;
1097 if ((u!=NULL)&&(u->rtyp==IDHDL))
1098 {
1099 idhdl h=(idhdl)u->data;
1100 h->lev=0;
1101 }
1102 loop
1103 {
1104 if (!SI_LINK_OPEN_P(l)) m2_end(0);
1105 if(d->f_read->is_eof) m2_end(0);
1106 leftv h=ssiRead1(l); /*contains an exit.... */
1107 if (feErrors != NULL && *feErrors != '\0')
1108 {
1109 // handle errors:
1110 PrintS(feErrors); /* currently quite simple */
1111 *feErrors = '\0';
1112 }
1113 ssiWrite(l,h);
1114 h->CleanUp();
1116 }
1117 /* never reached*/
1118 }
1119 else if (pid>0) /*fork: parent*/
1120 {
1121 d->pid=pid;
1122 si_close(pc[0]); si_close(cp[1]);
1123 d->f_write=fdopen(pc[1],"w");
1124 d->f_read=s_open(cp[0]);
1125 d->fd_read=cp[0];
1126 d->fd_write=pc[1];
1128 d->send_quit_at_exit=1;
1129 //d->r=currRing;
1130 //if (d->r!=NULL) d->r->ref++;
1131 }
1132 else
1133 {
1134 Werror("fork failed (%d)",errno);
1135 l->data=NULL;
1136 omFree(d);
1137 return TRUE;
1138 }
1139 }
1140 // ---------------------------------------------------------------------
1141 else if (strcmp(mode,"tcp")==0)
1142 {
1146 if(sockfd < 0)
1147 {
1148 WerrorS("ERROR opening socket");
1149 l->data=NULL;
1150 l->flags=0;
1151 omFree(d);
1152 return TRUE;
1153 }
1154 memset((char *) &serv_addr,0, sizeof(serv_addr));
1155 portno = 1025;
1156 serv_addr.sin_family = AF_INET;
1157 serv_addr.sin_addr.s_addr = INADDR_ANY;
1158 do
1159 {
1160 portno++;
1161 serv_addr.sin_port = htons(portno);
1162 if(portno > 50000)
1163 {
1164 WerrorS("ERROR on binding (no free port available?)");
1165 l->data=NULL;
1166 l->flags=0;
1167 omFree(d);
1168 return TRUE;
1169 }
1170 }
1171 while(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0);
1172 Print("waiting on port %d\n", portno);mflush();
1173 listen(sockfd,1);
1175 if(newsockfd < 0)
1176 {
1177 WerrorS("ERROR on accept");
1178 l->data=NULL;
1179 l->flags=0;
1180 omFree(d);
1181 return TRUE;
1182 }
1183 PrintS("client accepted\n");
1184 d->fd_read = newsockfd;
1185 d->fd_write = newsockfd;
1186 d->f_read = s_open(newsockfd);
1187 d->f_write = fdopen(newsockfd, "w");
1190 }
1191 // no ssi-Link on stdin or stdout
1192 else
1193 {
1194 Werror("invalid mode >>%s<< for ssi",mode);
1195 l->data=NULL;
1196 l->flags=0;
1197 omFree(d);
1198 return TRUE;
1199 }
1200 }
1201 // =========================================================================
1202 else /*now l->name!=NULL*/
1203 {
1204 // tcp mode
1205 if(strcmp(mode,"tcp")==0)
1206 {
1210 if(sockfd < 0)
1211 {
1212 WerrorS("ERROR opening socket");
1213 l->data=NULL;
1214 l->flags=0;
1215 omFree(d);
1216 return TRUE;
1217 }
1218 memset((char *) &serv_addr,0, sizeof(serv_addr));
1219 portno = 1025;
1220 serv_addr.sin_family = AF_INET;
1221 serv_addr.sin_addr.s_addr = INADDR_ANY;
1222 do
1223 {
1224 portno++;
1225 serv_addr.sin_port = htons(portno);
1226 if(portno > 50000)
1227 {
1228 WerrorS("ERROR on binding (no free port available?)");
1229 l->data=NULL;
1230 l->flags=0;
1231 return TRUE;
1232 }
1233 }
1234 while(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0);
1235 //Print("waiting on port %d\n", portno);mflush();
1236 listen(sockfd,1);
1237 char* cli_host = (char*)omAlloc(256);
1238 char* path = (char*)omAlloc(1024);
1239 int r = si_sscanf(l->name,"%255[^:]:%s",cli_host,path);
1240 if(r == 0)
1241 {
1242 WerrorS("ERROR: no host specified");
1243 l->data=NULL;
1244 l->flags=0;
1245 omFree(d);
1246 omFree(path);
1248 return TRUE;
1249 }
1250 else if(r == 1)
1251 {
1252 WarnS("program not specified, using /usr/local/bin/Singular");
1253 Warn("in line >>%s<<",my_yylinebuf);
1254 strcpy(path,"/usr/local/bin/Singular");
1255 }
1256 char* ssh_command = (char*)omAlloc(256);
1257 char* ser_host = (char*)omAlloc(64);
1258 if(strcmp(cli_host,"localhost")==0)
1259 strcpy(ser_host,"localhost");
1260 else
1262 if (strcmp(cli_host,"localhost")==0) /*avoid "ssh localhost" as key may change*/
1263 snprintf(ssh_command,256,"%s -q --batch --link=ssi --MPhost=%s --MPport=%d &",path,ser_host,portno);
1264 else
1265 snprintf(ssh_command,256,"ssh %s %s -q --batch --link=ssi --MPhost=%s --MPport=%d &",cli_host,path,ser_host,portno);
1266 //Print("client on %s started:%s\n",cli_host,path);
1267 omFree(path);
1269 if (TEST_OPT_PROT) { Print("running >>%s<<\n",ssh_command); }
1270 int re=system(ssh_command);
1271 if (re<0)
1272 {
1273 Werror("ERROR running `%s` (%d)",ssh_command,re);
1274 l->data=NULL;
1275 l->flags=0;
1276 omFree(d);
1277 return TRUE;
1278 }
1281 clilen = sizeof(cli_addr);
1283 if(newsockfd < 0)
1284 {
1285 WerrorS("ERROR on accept");
1286 l->data=NULL;
1287 l->flags=0;
1288 omFree(d);
1289 return TRUE;
1290 }
1291 //PrintS("client accepted\n");
1292 d->fd_read = newsockfd;
1293 d->fd_write = newsockfd;
1294 d->f_read = s_open(newsockfd);
1295 d->f_write = fdopen(newsockfd, "w");
1298 d->send_quit_at_exit=1;
1300 newlink->u=u;
1301 newlink->l=l;
1302 newlink->next=(void *)ssiToBeClosed;
1304 fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,si_opt_1,si_opt_2);
1305 }
1306 // ----------------------------------------------------------------------
1307 else if(strcmp(mode,"connect")==0)
1308 {
1309 char* host = (char*)omAlloc(256);
1310 int sockfd, portno;
1311 struct sockaddr_in serv_addr;
1312 struct hostent *server;
1313
1314 si_sscanf(l->name,"%255[^:]:%d",host,&portno);
1315 //Print("connect to host %s, port %d\n",host,portno);mflush();
1316 if (portno!=0)
1317 {
1319 if (sockfd < 0)
1320 {
1321 WerrorS("ERROR opening socket");
1322 l->flags=0;
1323 return TRUE;
1324 }
1326 if (server == NULL)
1327 {
1328 WerrorS("ERROR, no such host");
1329 l->flags=0;
1330 return TRUE;
1331 }
1332 memset((char *) &serv_addr, 0, sizeof(serv_addr));
1333 serv_addr.sin_family = AF_INET;
1334 memcpy((char *)&serv_addr.sin_addr.s_addr,
1335 (char *)server->h_addr,
1336 server->h_length);
1337 serv_addr.sin_port = htons(portno);
1338 if (si_connect(sockfd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0)
1339 {
1340 Werror("ERROR connecting(errno=%d)",errno);
1341 l->flags=0;
1342 return TRUE;
1343 }
1344 //PrintS("connected\n");mflush();
1345 d->f_read=s_open(sockfd);
1346 d->fd_read=sockfd;
1347 d->f_write=fdopen(sockfd,"w");
1348 d->fd_write=sockfd;
1350 omFree(host);
1351 }
1352 else
1353 {
1354 l->data=NULL;
1355 l->flags=0;
1356 omFree(d);
1357 return TRUE;
1358 }
1359 }
1360 // ======================================================================
1361 else
1362 {
1363 // normal link to a file
1364 if (FE_OPT_NO_SHELL_FLAG) {WerrorS("no links allowed");return TRUE;}
1365 FILE *outfile;
1366 char *filename=l->name;
1367
1368 if(filename[0]=='>')
1369 {
1370 if (filename[1]=='>')
1371 {
1372 filename+=2;
1373 mode = "a";
1374 }
1375 else
1376 {
1377 filename++;
1378 mode="w";
1379 }
1380 }
1381 outfile=myfopen(filename,mode);
1382 if (outfile!=NULL)
1383 {
1384 if (strcmp(l->mode,"r")==0)
1385 {
1386 fclose(outfile);
1387 d->f_read=s_open_by_name(filename);
1388 }
1389 else
1390 {
1391 d->f_write = outfile;
1392 fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,si_opt_1,si_opt_2);
1393 }
1394 }
1395 else
1396 {
1397 omFree(d);
1398 l->data=NULL;
1399 l->flags=0;
1400 return TRUE;
1401 }
1402 }
1403 }
1404 }
1405
1406 return FALSE;
1407}
Definition idrec.h:35
Class used for (list of) interpreter objects.
Definition subexpr.h:83
int rtyp
Definition subexpr.h:91
void * data
Definition subexpr.h:88
VAR BOOLEAN singular_in_batchmode
Definition cntrlc.cc:62
#define Print
Definition emacs.cc:80
#define Warn
Definition emacs.cc:77
#define WarnS
Definition emacs.cc:78
FILE * myfopen(const char *path, const char *mode)
Definition feFopen.cc:167
const char * feSetOptValue(feOptIndex opt, char *optarg)
Definition feOpt.cc:154
VAR char my_yylinebuf[80]
Definition febase.cc:44
char * fe_fgets_dummy(const char *, char *, int)
Definition feread.cc:455
char *(* fe_fgets_stdin)(const char *pr, char *s, int size)
Definition feread.cc:32
EXTERN_VAR omBin sleftv_bin
Definition ipid.h:145
STATIC_VAR Poly * h
Definition janet.cc:971
void m2_end(int i)
Definition misc_ip.cc:1100
#define omAlloc(size)
#define omFree(addr)
#define omFreeBin(addr, bin)
#define omFreeBinAddr(addr)
VAR unsigned si_opt_2
Definition options.c:6
VAR unsigned si_opt_1
Definition options.c:5
#define TEST_OPT_PROT
Definition options.h:104
void PrintS(const char *s)
Definition reporter.cc:284
VAR char * feErrors
Definition reporter.cc:47
#define mflush()
Definition reporter.h:58
idrec * idhdl
Definition ring.h:21
int raise_rlimit_nproc()
Definition rlimit.c:18
s_buff s_open_by_name(const char *n)
Definition s_buff.cc:39
pid_t pid
Definition s_buff.h:25
char send_quit_at_exit
Definition s_buff.h:28
VAR int sem_acquired[SIPC_MAX_SEMAPHORES]
Definition semaphore.c:25
#define SIPC_MAX_SEMAPHORES
Definition simpleipc.h:10
#define IDHDL
Definition tok.h:31
@ MAX_TOK
Definition tok.h:220

◆ ssiRead1()

leftv ssiRead1 ( si_link  l)

Definition at line 1528 of file ssiLink.cc.

1529{
1530 ssiInfo *d = (ssiInfo *)l->data;
1532 int t=0;
1533 t=s_readint(d->f_read);
1534 //Print("got type %d\n",t);
1535 switch(t)
1536 {
1537 case 1:res->rtyp=INT_CMD;
1538 res->data=(char *)(long)ssiReadInt(d->f_read);
1539 //Print("int: %d\n",(int)(long)res->data);
1540 break;
1541 case 2:res->rtyp=STRING_CMD;
1542 res->data=(char *)ssiReadString(d);
1543 //Print("str: %s\n",(char*)res->data);
1544 break;
1545 case 3:res->rtyp=NUMBER_CMD;
1546 if (d->r==NULL) goto no_ring;
1547 ssiCheckCurrRing(d->r);
1548 res->data=(char *)ssiReadNumber(d);
1549 //Print("number\n");
1550 break;
1551 case 4:res->rtyp=BIGINT_CMD;
1552 res->data=(char *)ssiReadBigInt(d);
1553 //Print("bigint\n");
1554 break;
1555 case 15:
1556 case 5:{
1557 //Print("ring %d\n",t);
1558 d->r=ssiReadRing(d);
1559 if (errorreported) return NULL;
1560 res->data=(char*)d->r;
1561 if (d->r!=NULL) rIncRefCnt(d->r);
1562 res->rtyp=RING_CMD;
1563 if (t==15) // setring
1564 {
1565 if(ssiSetCurrRing(d->r)) { d->r=currRing; }
1567 return ssiRead1(l);
1568 }
1569 }
1570 break;
1571 case 6:res->rtyp=POLY_CMD;
1572 //Print("poly\n");
1573 if (d->r==NULL) goto no_ring;
1574 ssiCheckCurrRing(d->r);
1575 res->data=(char*)ssiReadPoly(d);
1576 break;
1577 case 7:res->rtyp=IDEAL_CMD;
1578 //Print("ideal\n");
1579 if (d->r==NULL) goto no_ring;
1580 ssiCheckCurrRing(d->r);
1581 res->data=(char*)ssiReadIdeal(d);
1582 break;
1583 case 8:res->rtyp=MATRIX_CMD;
1584 //Print("matrix\n");
1585 if (d->r==NULL) goto no_ring;
1586 ssiCheckCurrRing(d->r);
1587 res->data=(char*)ssiReadMatrix(d);
1588 break;
1589 case 9:res->rtyp=VECTOR_CMD;
1590 //Print("vector\n");
1591 if (d->r==NULL) goto no_ring;
1592 ssiCheckCurrRing(d->r);
1593 res->data=(char*)ssiReadPoly(d);
1594 break;
1595 case 10:
1596 case 22:if (t==22) res->rtyp=SMATRIX_CMD;
1597 else res->rtyp=MODUL_CMD;
1598 //Print("module/smatrix %d\n",t);
1599 if (d->r==NULL) goto no_ring;
1600 ssiCheckCurrRing(d->r);
1601 {
1602 int rk=s_readint(d->f_read);
1603 ideal M=ssiReadIdeal(d);
1604 M->rank=rk;
1605 res->data=(char*)M;
1606 }
1607 break;
1608 case 11:
1609 {
1610 //Print("cmd\n",t);
1611 res->rtyp=COMMAND;
1612 res->data=ssiReadCommand(l);
1613 int nok=res->Eval();
1614 if (nok) WerrorS("error in eval");
1615 break;
1616 }
1617 case 12: /*DEF_CMD*/
1618 {
1619 //Print("def\n",t);
1620 res->rtyp=0;
1621 res->name=(char *)ssiReadString(d);
1622 int nok=res->Eval();
1623 if (nok) WerrorS("error in name lookup");
1624 break;
1625 }
1626 case 13: res->rtyp=PROC_CMD;
1627 res->data=ssiReadProc(d);
1628 break;
1629 case 14: res->rtyp=LIST_CMD;
1630 res->data=ssiReadList(l);
1631 break;
1632 case 16: res->rtyp=NONE; res->data=NULL;
1633 break;
1634 case 17: res->rtyp=INTVEC_CMD;
1635 res->data=ssiReadIntvec(d);
1636 break;
1637 case 18: res->rtyp=INTMAT_CMD;
1638 res->data=ssiReadIntmat(d);
1639 break;
1640 case 19: res->rtyp=BIGINTMAT_CMD;
1641 res->data=ssiReadBigintmat(d);
1642 break;
1643 case 20: ssiReadBlackbox(res,l);
1644 break;
1645 case 21: ssiReadAttrib(res,l);
1646 break;
1647 case 23: ssiReadRingProperties(l);
1648 return ssiRead1(l);
1649 break;
1650 case 24: res->rtyp=BIGINTVEC_CMD;
1651 res->data=ssiReadBigintvec(d);
1652 break;
1653 // ------------
1654 case 98: // version
1655 {
1656 int n98_v,n98_m;
1658 n98_v=s_readint(d->f_read);
1659 n98_m=s_readint(d->f_read);
1660 n98_o1=s_readint(d->f_read);
1661 n98_o2=s_readint(d->f_read);
1662 if ((n98_v!=SSI_VERSION) ||(n98_m!=MAX_TOK))
1663 {
1664 Print("incompatible versions of ssi: %d/%d vs %d/%d\n",
1666 }
1667 #ifndef SING_NDEBUG
1668 if (TEST_OPT_DEBUG)
1669 Print("// opening ssi-%d, MAX_TOK=%d\n",n98_v,n98_m);
1670 #endif
1674 return ssiRead1(l);
1675 }
1676 case 99: omFreeBin(res,sleftv_bin); ssiClose(l); m2_end(0);
1677 break; /*to make compiler happy*/
1678 case 0: if (s_iseof(d->f_read))
1679 {
1680 ssiClose(l);
1681 }
1682 res->rtyp=DEF_CMD;
1683 break;
1684 default: Werror("not implemented (t:%d)",t);
1686 res=NULL;
1687 break;
1688 }
1689 // if currRing is required for the result, but lost
1690 // define "ssiRing%d" as currRing:
1691 if ((d->r!=NULL)
1692 && (currRing!=d->r)
1693 && (res->RingDependend()))
1694 {
1695 if(ssiSetCurrRing(d->r)) { d->r=currRing; }
1696 }
1697 return res;
1698no_ring: WerrorS("no ring");
1700 return NULL;
1701}
CanonicalForm res
Definition facAbsFact.cc:60
VAR short errorreported
Definition feFopen.cc:23
@ IDEAL_CMD
Definition grammar.cc:285
@ MATRIX_CMD
Definition grammar.cc:287
@ BIGINTMAT_CMD
Definition grammar.cc:278
@ PROC_CMD
Definition grammar.cc:281
@ INTMAT_CMD
Definition grammar.cc:280
@ MODUL_CMD
Definition grammar.cc:288
@ SMATRIX_CMD
Definition grammar.cc:292
@ VECTOR_CMD
Definition grammar.cc:293
@ BIGINTVEC_CMD
Definition grammar.cc:279
@ NUMBER_CMD
Definition grammar.cc:289
@ POLY_CMD
Definition grammar.cc:290
@ RING_CMD
Definition grammar.cc:282
#define TEST_OPT_DEBUG
Definition options.h:109
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
static ring rIncRefCnt(ring r)
Definition ring.h:846
int s_readint(s_buff F)
Definition s_buff.cc:112
#define M
Definition sirandom.c:25
sleftv * leftv
Definition structs.h:57
#define BITSET
Definition structs.h:16
@ BIGINT_CMD
Definition tok.h:38
@ LIST_CMD
Definition tok.h:118
@ INTVEC_CMD
Definition tok.h:101
@ DEF_CMD
Definition tok.h:58
@ STRING_CMD
Definition tok.h:187
@ INT_CMD
Definition tok.h:96
#define NONE
Definition tok.h:223
#define COMMAND
Definition tok.h:29

◆ ssiRead2()

leftv ssiRead2 ( si_link  l,
leftv  key 
)

◆ ssiReservePort()

int ssiReservePort ( int  clients)

Definition at line 2212 of file ssiLink.cc.

2213{
2214 if (ssiReserved_P!=0)
2215 {
2216 WerrorS("ERROR already a reserved port requested");
2217 return 0;
2218 }
2219 int portno;
2221 if(ssiReserved_sockfd < 0)
2222 {
2223 WerrorS("ERROR opening socket");
2224 return 0;
2225 }
2226 memset((char *) &ssiResverd_serv_addr,0, sizeof(ssiResverd_serv_addr));
2227 portno = 1025;
2228 ssiResverd_serv_addr.sin_family = AF_INET;
2229 ssiResverd_serv_addr.sin_addr.s_addr = INADDR_ANY;
2230 do
2231 {
2232 portno++;
2233 ssiResverd_serv_addr.sin_port = htons(portno);
2234 if(portno > 50000)
2235 {
2236 WerrorS("ERROR on binding (no free port available?)");
2237 return 0;
2238 }
2239 }
2244 return portno;
2245}

◆ ssiWrite()

BOOLEAN ssiWrite ( si_link  l,
leftv  v 
)

Definition at line 1722 of file ssiLink.cc.

1723{
1724 if(SI_LINK_W_OPEN_P(l)==0)
1726 ssiInfo *d = (ssiInfo *)l->data;
1727 d->level++;
1728 //FILE *fich=d->f;
1729 while (data!=NULL)
1730 {
1731 int tt=data->Typ();
1732 void *dd=data->Data();
1733 attr *aa=data->Attribute();
1734 if ((aa!=NULL) && ((*aa)!=NULL)) // n user attributes
1735 {
1736 attr a=*aa;
1737 int n=0;
1738 while(a!=NULL) { n++; a=a->next;}
1739 fprintf(d->f_write,"21 %d %d ",data->flag,n);
1740 }
1741 else if (data->flag!=0) // only "flag" attributes
1742 {
1743 fprintf(d->f_write,"21 %d 0 ",data->flag);
1744 }
1745 if ((dd==NULL) && (data->name!=NULL) && (tt==0)) tt=DEF_CMD;
1746 // return pure undefined names as def
1747
1748 switch(tt /*data->Typ()*/)
1749 {
1750 case 0: /*error*/
1751 case NONE/* nothing*/:fputs("16 ",d->f_write);
1752 break;
1753 case STRING_CMD: fputs("2 ",d->f_write);
1754 ssiWriteString(d,(char *)dd);
1755 break;
1756 case INT_CMD: fputs("1 ",d->f_write);
1757 ssiWriteInt(d,(int)(long)dd);
1758 break;
1759 case BIGINT_CMD:fputs("4 ",d->f_write);
1761 break;
1762 case NUMBER_CMD:
1763 if (d->r!=currRing)
1764 {
1765 fputs("15 ",d->f_write);
1767 if (d->level<=1) fputc('\n',d->f_write);
1768 }
1769 fputs("3 ",d->f_write);
1771 break;
1772 case RING_CMD:fputs("5 ",d->f_write);
1773 ssiWriteRing(d,(ring)dd);
1774 break;
1775 case BUCKET_CMD:
1776 {
1778 if (d->r!=sBucketGetRing(b))
1779 {
1780 fputs("15 ",d->f_write);
1782 if (d->level<=1) fputc('\n',d->f_write);
1783 }
1784 fputs("6 ",d->f_write);
1786 break;
1787 }
1788 case POLY_CMD:
1789 case VECTOR_CMD:
1790 if (d->r!=currRing)
1791 {
1792 fputs("15 ",d->f_write);
1794 if (d->level<=1) fputc('\n',d->f_write);
1795 }
1796 if(tt==POLY_CMD) fputs("6 ",d->f_write);
1797 else fputs("9 ",d->f_write);
1798 ssiWritePoly(d,tt,(poly)dd);
1799 break;
1800 case IDEAL_CMD:
1801 case MODUL_CMD:
1802 case MATRIX_CMD:
1803 case SMATRIX_CMD:
1804 if (d->r!=currRing)
1805 {
1806 fputs("15 ",d->f_write);
1808 if (d->level<=1) fputc('\n',d->f_write);
1809 }
1810 if(tt==IDEAL_CMD) fputs("7 ",d->f_write);
1811 else if(tt==MATRIX_CMD) fputs("8 ",d->f_write);
1812 else /* tt==MODUL_CMD, SMATRIX_CMD*/
1813 {
1814 ideal M=(ideal)dd;
1815 if (tt==MODUL_CMD)
1816 fprintf(d->f_write,"10 %d ",(int)M->rank);
1817 else /*(tt==SMATRIX_CMD)*/
1818 fprintf(d->f_write,"22 %d ",(int)M->rank);
1819 }
1821 break;
1822 case COMMAND:
1823 fputs("11 ",d->f_write);
1825 break;
1826 case DEF_CMD: /* not evaluated stuff in quotes */
1827 fputs("12 ",d->f_write);
1828 ssiWriteString(d,data->Name());
1829 break;
1830 case PROC_CMD:
1831 fputs("13 ",d->f_write);
1833 break;
1834 case LIST_CMD:
1835 fputs("14 ",d->f_write);
1837 break;
1838 case INTVEC_CMD:
1839 fputs("17 ",d->f_write);
1840 ssiWriteIntvec(d,(intvec *)dd);
1841 break;
1842 case INTMAT_CMD:
1843 fputs("18 ",d->f_write);
1844 ssiWriteIntmat(d,(intvec *)dd);
1845 break;
1846 case BIGINTMAT_CMD:
1847 fputs("19 ",d->f_write);
1849 break;
1850 case BIGINTVEC_CMD:
1851 fputs("24 ",d->f_write);
1853 break;
1854 default:
1855 if (tt>MAX_TOK)
1856 {
1858 fputs("20 ",d->f_write);
1859 b->blackbox_serialize(b,dd,l);
1860 }
1861 else
1862 {
1863 Werror("not implemented (t:%d, rtyp:%d)",tt, data->rtyp);
1864 d->level=0;
1865 return TRUE;
1866 }
1867 break;
1868 }
1869 if (d->level<=1) { fputc('\n',d->f_write); fflush(d->f_write); }
1870 data=data->next;
1871 }
1872 d->level--;
1873 return FALSE;
1874}
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
Definition blackbox.cc:17
CanonicalForm b
Definition cfModGcd.cc:4111
Matrices of numbers.
Definition bigintmat.h:51
Definition attrib.h:21
attr next
Definition attrib.h:26
Definition lists.h:24
@ BUCKET_CMD
Definition grammar.cc:284
ip_command * command
Definition ipid.h:23
poly sBucketPeek(sBucket_pt b)
Definition sbuckets.cc:455
ring sBucketGetRing(const sBucket_pt bucket)
Returns bucket ring.
Definition sbuckets.cc:46
sBucket * sBucket_pt
Definition sbuckets.h:16