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 2301 of file ssiLink.cc.

2302{
2303 pid_t kidpid;
2304 int status;
2305
2306 loop
2307 {
2309 if (kidpid==-1)
2310 {
2311 /* continue on interruption (EINTR): */
2312 if (errno == EINTR) continue;
2313 /* break on anything else (EINVAL or ECHILD according to manpage): */
2314 break;
2315 }
2316 else if (kidpid==0) break; /* no more children to process, so break */
2317
2318 //printf("Child %ld terminated\n", kidpid);
2320 while((hh!=NULL)&&(ssiToBeClosed_inactive))
2321 {
2322 if((hh->l!=NULL) && (hh->l->m->Open==ssiOpen))
2323 {
2324 ssiInfo *d = (ssiInfo *)hh->l->data;
2325 if(d->pid==kidpid)
2326 {
2328 {
2330 slClose(hh->l);
2332 break;
2333 }
2334 else break;
2335 }
2336 else hh=(link_list)hh->next;
2337 }
2338 else hh=(link_list)hh->next;
2339 }
2340 }
2341}
#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 1861 of file ssiLink.cc.

1862{
1863 s->Open=ssiOpen;
1864 s->Close=ssiClose;
1865 s->Kill=ssiClose;
1866 s->Read=ssiRead1;
1867 s->Read2=(slRead2Proc)NULL;
1868 s->Write=ssiWrite;
1869 s->Dump=ssiDump;
1870 s->GetDump=ssiGetDump;
1871
1872 s->Status=slStatusSsi;
1873 s->SetRing=ssiSetRing;
1874 s->type="ssi";
1875 return s;
1876}
const CanonicalForm int s
Definition facAbsFact.cc:51

◆ slStatusSsi()

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

Definition at line 1878 of file ssiLink.cc.

1879{
1880 ssiInfo *d=(ssiInfo*)l->data;
1881 if (d==NULL) return "not open";
1882 if (((strcmp(l->mode,"fork")==0)
1883 ||(strcmp(l->mode,"tcp")==0)
1884 ||(strcmp(l->mode,"connect")==0))
1885 && (strcmp(request, "read") == 0))
1886 {
1887 if (s_isready(d->f_read)) return "ready";
1888#if defined(HAVE_POLL)
1889 pollfd pfd;
1890 loop
1891 {
1892 /* Don't block. Return socket status immediately. */
1893 pfd.fd=d->fd_read;
1894 pfd.events=POLLIN;
1895 //Print("test fd %d\n",d->fd_read);
1896 /* check with select: chars waiting: no -> not ready */
1897 switch (si_poll(&pfd,1,0))
1898 {
1899 case 0: /* not ready */ return "not ready";
1900 case -1: /*error*/ return "error";
1901 case 1: /*ready ? */ break;
1902 }
1903#else
1904 fd_set mask;
1905 struct timeval wt;
1906 if (FD_SETSIZE<=d->fd_read)
1907 {
1908 Werror("file descriptor number too high (%d)",d->fd_read);
1909 return "error";
1910 }
1911
1912 loop
1913 {
1914 /* Don't block. Return socket status immediately. */
1915 wt.tv_sec = 0;
1916 wt.tv_usec = 0;
1917
1918 FD_ZERO(&mask);
1919 FD_SET(d->fd_read, &mask);
1920 //Print("test fd %d\n",d->fd_read);
1921 /* check with select: chars waiting: no -> not ready */
1922 switch (si_select(d->fd_read+1, &mask, NULL, NULL, &wt))
1923 {
1924 case 0: /* not ready */ return "not ready";
1925 case -1: /*error*/ return "error";
1926 case 1: /*ready ? */ break;
1927 }
1928#endif
1929 /* yes: read 1 char*/
1930 /* if \n, check again with select else ungetc(c), ready*/
1931 int c=s_getc(d->f_read);
1932 //Print("try c=%d\n",c);
1933 if (c== -1) return "eof"; /* eof or error */
1934 else if (isdigit(c))
1935 { s_ungetc(c,d->f_read); return "ready"; }
1936 else if (c>' ')
1937 {
1938 Werror("unknown char in ssiLink(%d)",c);
1939 return "error";
1940 }
1941 /* else: next char */
1942 }
1943 }
1944 else if (strcmp(request, "read") == 0)
1945 {
1946 if (SI_LINK_R_OPEN_P(l) && (!s_iseof(d->f_read)) && (s_isready(d->f_read))) return "ready";
1947 else return "not ready";
1948 }
1949 else if (strcmp(request, "write") == 0)
1950 {
1951 if (SI_LINK_W_OPEN_P(l)) return "ready";
1952 else return "not ready";
1953 }
1954 else return "unknown status request";
1955}
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 1425 of file ssiLink.cc.

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

2231{
2232 if (ssiReserved_P==0)
2233 {
2234 WerrorS("ERROR no reserved port requested");
2235 return NULL;
2236 }
2237 struct sockaddr_in cli_addr;
2238 int clilen = sizeof(cli_addr);
2240 if(newsockfd < 0)
2241 {
2242 Werror("ERROR on accept (errno=%d)",errno);
2243 return NULL;
2244 }
2247 si_link_extension prev = s;
2248 while (strcmp(s->type, "ssi") != 0)
2249 {
2250 if (s->next == NULL)
2251 {
2252 prev = s;
2253 s = NULL;
2254 break;
2255 }
2256 else
2257 {
2258 s = s->next;
2259 }
2260 }
2261 if (s != NULL)
2262 l->m = s;
2263 else
2264 {
2266 prev->next=slInitSsiExtension(ns);
2267 l->m = prev->next;
2268 }
2269 l->name=omStrDup("");
2270 l->mode=omStrDup("tcp");
2271 l->ref=1;
2272 ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
2273 l->data=d;
2274 d->fd_read = newsockfd;
2275 d->fd_write = newsockfd;
2276 d->f_read = s_open(newsockfd);
2277 d->f_write = fdopen(newsockfd, "w");
2280 if (ssiReserved_Clients<=0)
2281 {
2282 ssiReserved_P=0;
2284 }
2285 return l;
2286}
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 995 of file ssiLink.cc.

996{
997 if (l!=NULL)
998 {
999 const char *mode;
1000 ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
1001 if (flag & SI_LINK_OPEN)
1002 {
1003 if (l->mode[0] != '\0' && (strcmp(l->mode, "r") == 0))
1004 flag = SI_LINK_READ;
1005 else flag = SI_LINK_WRITE;
1006 }
1007
1008 if (flag == SI_LINK_READ) mode = "r";
1009 else if (strcmp(l->mode, "w") == 0) mode = "w";
1010 else if (strcmp(l->mode, "fork") == 0) mode = "fork";
1011 else if (strcmp(l->mode, "tcp") == 0) mode = "tcp";
1012 else if (strcmp(l->mode, "connect") == 0) mode = "connect";
1013 else mode = "a";
1014
1015
1016 SI_LINK_SET_OPEN_P(l, flag);
1017 if(l->data!=NULL) omFreeSize(l->data,sizeof(ssiInfo));
1018 l->data=d;
1019 omFreeBinAddr(l->mode);
1020 l->mode = omStrDup(mode);
1021
1022 if (l->name[0] == '\0')
1023 {
1024 if (strcmp(mode,"fork")==0)
1025 {
1026 int pc[2];
1027 int cp[2];
1028 int err1=pipe(pc);
1029 int err2=pipe(cp);
1030 if (err1 || err2)
1031 {
1032 Werror("pipe failed with %d\n",errno);
1033 return TRUE;
1034 }
1036 n->u=u;
1037 n->l=l;
1038 n->next=(void *)ssiToBeClosed;
1039 ssiToBeClosed=n;
1040
1041 pid_t pid = fork();
1042 if (pid == -1 && errno == EAGAIN) // RLIMIT_NPROC too low?
1043 {
1045 pid = fork();
1046 }
1047 if (pid == -1)
1048 {
1049 WerrorS("could not fork");
1050 }
1051 if (pid==0) /*fork: child*/
1052 {
1053 /* block SIGINT */
1058 /* set #cpu to 1 for the child:*/
1060
1062 /* we know: l is the first entry in ssiToBeClosed-list */
1063 while(hh!=NULL)
1064 {
1066 ssiInfo *dd=(ssiInfo*)hh->l->data;
1067 s_close(dd->f_read);
1068 fclose(dd->f_write);
1069 if (dd->r!=NULL) rKill(dd->r);
1070 omFreeSize((ADDRESS)dd,(sizeof *dd));
1071 hh->l->data=NULL;
1072 link_list nn=(link_list)hh->next;
1073 omFree(hh);
1074 hh=nn;
1075 }
1077#ifdef HAVE_SIMPLEIPC
1079#endif // HAVE_SIMPLEIPC
1080 si_close(pc[1]); si_close(cp[0]);
1081 d->f_write=fdopen(cp[1],"w");
1082 d->f_read=s_open(pc[0]);
1083 d->fd_read=pc[0];
1084 d->fd_write=cp[1];
1085 //d->r=currRing;
1086 //if (d->r!=NULL) d->r->ref++;
1087 l->data=d;
1088 omFreeBinAddr(l->mode);
1089 l->mode = omStrDup(mode);
1092 //myynest=0;
1094 if ((u!=NULL)&&(u->rtyp==IDHDL))
1095 {
1096 idhdl h=(idhdl)u->data;
1097 h->lev=0;
1098 }
1099 loop
1100 {
1101 if (!SI_LINK_OPEN_P(l)) m2_end(0);
1102 if(d->f_read->is_eof) m2_end(0);
1103 leftv h=ssiRead1(l); /*contains an exit.... */
1104 if (feErrors != NULL && *feErrors != '\0')
1105 {
1106 // handle errors:
1107 PrintS(feErrors); /* currently quite simple */
1108 *feErrors = '\0';
1109 }
1110 ssiWrite(l,h);
1111 h->CleanUp();
1113 }
1114 /* never reached*/
1115 }
1116 else if (pid>0) /*fork: parent*/
1117 {
1118 d->pid=pid;
1119 si_close(pc[0]); si_close(cp[1]);
1120 d->f_write=fdopen(pc[1],"w");
1121 d->f_read=s_open(cp[0]);
1122 d->fd_read=cp[0];
1123 d->fd_write=pc[1];
1125 d->send_quit_at_exit=1;
1126 //d->r=currRing;
1127 //if (d->r!=NULL) d->r->ref++;
1128 }
1129 else
1130 {
1131 Werror("fork failed (%d)",errno);
1132 l->data=NULL;
1133 omFree(d);
1134 return TRUE;
1135 }
1136 }
1137 // ---------------------------------------------------------------------
1138 else if (strcmp(mode,"tcp")==0)
1139 {
1143 if(sockfd < 0)
1144 {
1145 WerrorS("ERROR opening socket");
1146 l->data=NULL;
1147 l->flags=0;
1148 omFree(d);
1149 return TRUE;
1150 }
1151 memset((char *) &serv_addr,0, sizeof(serv_addr));
1152 portno = 1025;
1153 serv_addr.sin_family = AF_INET;
1154 serv_addr.sin_addr.s_addr = INADDR_ANY;
1155 do
1156 {
1157 portno++;
1158 serv_addr.sin_port = htons(portno);
1159 if(portno > 50000)
1160 {
1161 WerrorS("ERROR on binding (no free port available?)");
1162 l->data=NULL;
1163 l->flags=0;
1164 omFree(d);
1165 return TRUE;
1166 }
1167 }
1168 while(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0);
1169 Print("waiting on port %d\n", portno);mflush();
1170 listen(sockfd,1);
1172 if(newsockfd < 0)
1173 {
1174 WerrorS("ERROR on accept");
1175 l->data=NULL;
1176 l->flags=0;
1177 omFree(d);
1178 return TRUE;
1179 }
1180 PrintS("client accepted\n");
1181 d->fd_read = newsockfd;
1182 d->fd_write = newsockfd;
1183 d->f_read = s_open(newsockfd);
1184 d->f_write = fdopen(newsockfd, "w");
1187 }
1188 // no ssi-Link on stdin or stdout
1189 else
1190 {
1191 Werror("invalid mode >>%s<< for ssi",mode);
1192 l->data=NULL;
1193 l->flags=0;
1194 omFree(d);
1195 return TRUE;
1196 }
1197 }
1198 // =========================================================================
1199 else /*now l->name!=NULL*/
1200 {
1201 // tcp mode
1202 if(strcmp(mode,"tcp")==0)
1203 {
1207 if(sockfd < 0)
1208 {
1209 WerrorS("ERROR opening socket");
1210 l->data=NULL;
1211 l->flags=0;
1212 omFree(d);
1213 return TRUE;
1214 }
1215 memset((char *) &serv_addr,0, sizeof(serv_addr));
1216 portno = 1025;
1217 serv_addr.sin_family = AF_INET;
1218 serv_addr.sin_addr.s_addr = INADDR_ANY;
1219 do
1220 {
1221 portno++;
1222 serv_addr.sin_port = htons(portno);
1223 if(portno > 50000)
1224 {
1225 WerrorS("ERROR on binding (no free port available?)");
1226 l->data=NULL;
1227 l->flags=0;
1228 return TRUE;
1229 }
1230 }
1231 while(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0);
1232 //Print("waiting on port %d\n", portno);mflush();
1233 listen(sockfd,1);
1234 char* cli_host = (char*)omAlloc(256);
1235 char* path = (char*)omAlloc(1024);
1236 int r = si_sscanf(l->name,"%255[^:]:%s",cli_host,path);
1237 if(r == 0)
1238 {
1239 WerrorS("ERROR: no host specified");
1240 l->data=NULL;
1241 l->flags=0;
1242 omFree(d);
1243 omFree(path);
1245 return TRUE;
1246 }
1247 else if(r == 1)
1248 {
1249 WarnS("program not specified, using /usr/local/bin/Singular");
1250 Warn("in line >>%s<<",my_yylinebuf);
1251 strcpy(path,"/usr/local/bin/Singular");
1252 }
1253 char* ssh_command = (char*)omAlloc(256);
1254 char* ser_host = (char*)omAlloc(64);
1255 if(strcmp(cli_host,"localhost")==0)
1256 strcpy(ser_host,"localhost");
1257 else
1259 if (strcmp(cli_host,"localhost")==0) /*avoid "ssh localhost" as key may change*/
1260 snprintf(ssh_command,256,"%s -q --batch --link=ssi --MPhost=%s --MPport=%d &",path,ser_host,portno);
1261 else
1262 snprintf(ssh_command,256,"ssh %s %s -q --batch --link=ssi --MPhost=%s --MPport=%d &",cli_host,path,ser_host,portno);
1263 //Print("client on %s started:%s\n",cli_host,path);
1264 omFree(path);
1266 if (TEST_OPT_PROT) { Print("running >>%s<<\n",ssh_command); }
1267 int re=system(ssh_command);
1268 if (re<0)
1269 {
1270 Werror("ERROR running `%s` (%d)",ssh_command,re);
1271 l->data=NULL;
1272 l->flags=0;
1273 omFree(d);
1274 return TRUE;
1275 }
1278 clilen = sizeof(cli_addr);
1280 if(newsockfd < 0)
1281 {
1282 WerrorS("ERROR on accept");
1283 l->data=NULL;
1284 l->flags=0;
1285 omFree(d);
1286 return TRUE;
1287 }
1288 //PrintS("client accepted\n");
1289 d->fd_read = newsockfd;
1290 d->fd_write = newsockfd;
1291 d->f_read = s_open(newsockfd);
1292 d->f_write = fdopen(newsockfd, "w");
1295 d->send_quit_at_exit=1;
1297 newlink->u=u;
1298 newlink->l=l;
1299 newlink->next=(void *)ssiToBeClosed;
1301 fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,si_opt_1,si_opt_2);
1302 }
1303 // ----------------------------------------------------------------------
1304 else if(strcmp(mode,"connect")==0)
1305 {
1306 char* host = (char*)omAlloc(256);
1307 int sockfd, portno;
1308 struct sockaddr_in serv_addr;
1309 struct hostent *server;
1310
1311 si_sscanf(l->name,"%255[^:]:%d",host,&portno);
1312 //Print("connect to host %s, port %d\n",host,portno);mflush();
1313 if (portno!=0)
1314 {
1316 if (sockfd < 0)
1317 {
1318 WerrorS("ERROR opening socket");
1319 l->flags=0;
1320 return TRUE;
1321 }
1323 if (server == NULL)
1324 {
1325 WerrorS("ERROR, no such host");
1326 l->flags=0;
1327 return TRUE;
1328 }
1329 memset((char *) &serv_addr, 0, sizeof(serv_addr));
1330 serv_addr.sin_family = AF_INET;
1331 memcpy((char *)&serv_addr.sin_addr.s_addr,
1332 (char *)server->h_addr,
1333 server->h_length);
1334 serv_addr.sin_port = htons(portno);
1335 if (si_connect(sockfd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0)
1336 {
1337 Werror("ERROR connecting(errno=%d)",errno);
1338 l->flags=0;
1339 return TRUE;
1340 }
1341 //PrintS("connected\n");mflush();
1342 d->f_read=s_open(sockfd);
1343 d->fd_read=sockfd;
1344 d->f_write=fdopen(sockfd,"w");
1345 d->fd_write=sockfd;
1347 omFree(host);
1348 }
1349 else
1350 {
1351 l->data=NULL;
1352 l->flags=0;
1353 omFree(d);
1354 return TRUE;
1355 }
1356 }
1357 // ======================================================================
1358 else
1359 {
1360 // normal link to a file
1361 FILE *outfile;
1362 char *filename=l->name;
1363
1364 if(filename[0]=='>')
1365 {
1366 if (filename[1]=='>')
1367 {
1368 filename+=2;
1369 mode = "a";
1370 }
1371 else
1372 {
1373 filename++;
1374 mode="w";
1375 }
1376 }
1377 outfile=myfopen(filename,mode);
1378 if (outfile!=NULL)
1379 {
1380 if (strcmp(l->mode,"r")==0)
1381 {
1382 fclose(outfile);
1383 d->f_read=s_open_by_name(filename);
1384 }
1385 else
1386 {
1387 d->f_write = outfile;
1388 fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,si_opt_1,si_opt_2);
1389 }
1390 }
1391 else
1392 {
1393 omFree(d);
1394 l->data=NULL;
1395 l->flags=0;
1396 return TRUE;
1397 }
1398 }
1399 }
1400 }
1401
1402 return FALSE;
1403}
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:103
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 1524 of file ssiLink.cc.

1525{
1526 ssiInfo *d = (ssiInfo *)l->data;
1528 int t=0;
1529 t=s_readint(d->f_read);
1530 //Print("got type %d\n",t);
1531 switch(t)
1532 {
1533 case 1:res->rtyp=INT_CMD;
1534 res->data=(char *)(long)ssiReadInt(d->f_read);
1535 break;
1536 case 2:res->rtyp=STRING_CMD;
1537 res->data=(char *)ssiReadString(d);
1538 break;
1539 case 3:res->rtyp=NUMBER_CMD;
1540 if (d->r==NULL) goto no_ring;
1541 ssiCheckCurrRing(d->r);
1542 res->data=(char *)ssiReadNumber(d);
1543 break;
1544 case 4:res->rtyp=BIGINT_CMD;
1545 res->data=(char *)ssiReadBigInt(d);
1546 break;
1547 case 15:
1548 case 5:{
1549 d->r=ssiReadRing(d);
1550 if (errorreported) return NULL;
1551 res->data=(char*)d->r;
1552 if (d->r!=NULL) rIncRefCnt(d->r);
1553 res->rtyp=RING_CMD;
1554 if (t==15) // setring
1555 {
1556 if(ssiSetCurrRing(d->r)) { d->r=currRing; }
1558 return ssiRead1(l);
1559 }
1560 }
1561 break;
1562 case 6:res->rtyp=POLY_CMD;
1563 if (d->r==NULL) goto no_ring;
1564 ssiCheckCurrRing(d->r);
1565 res->data=(char*)ssiReadPoly(d);
1566 break;
1567 case 7:res->rtyp=IDEAL_CMD;
1568 if (d->r==NULL) goto no_ring;
1569 ssiCheckCurrRing(d->r);
1570 res->data=(char*)ssiReadIdeal(d);
1571 break;
1572 case 8:res->rtyp=MATRIX_CMD;
1573 if (d->r==NULL) goto no_ring;
1574 ssiCheckCurrRing(d->r);
1575 res->data=(char*)ssiReadMatrix(d);
1576 break;
1577 case 9:res->rtyp=VECTOR_CMD;
1578 if (d->r==NULL) goto no_ring;
1579 ssiCheckCurrRing(d->r);
1580 res->data=(char*)ssiReadPoly(d);
1581 break;
1582 case 10:
1583 case 22:if (t==22) res->rtyp=SMATRIX_CMD;
1584 else res->rtyp=MODUL_CMD;
1585 if (d->r==NULL) goto no_ring;
1586 ssiCheckCurrRing(d->r);
1587 {
1588 int rk=s_readint(d->f_read);
1589 ideal M=ssiReadIdeal(d);
1590 M->rank=rk;
1591 res->data=(char*)M;
1592 }
1593 break;
1594 case 11:
1595 {
1596 res->rtyp=COMMAND;
1597 res->data=ssiReadCommand(l);
1598 int nok=res->Eval();
1599 if (nok) WerrorS("error in eval");
1600 break;
1601 }
1602 case 12: /*DEF_CMD*/
1603 {
1604 res->rtyp=0;
1605 res->name=(char *)ssiReadString(d);
1606 int nok=res->Eval();
1607 if (nok) WerrorS("error in name lookup");
1608 break;
1609 }
1610 case 13: res->rtyp=PROC_CMD;
1611 res->data=ssiReadProc(d);
1612 break;
1613 case 14: res->rtyp=LIST_CMD;
1614 res->data=ssiReadList(l);
1615 break;
1616 case 16: res->rtyp=NONE; res->data=NULL;
1617 break;
1618 case 17: res->rtyp=INTVEC_CMD;
1619 res->data=ssiReadIntvec(d);
1620 break;
1621 case 18: res->rtyp=INTMAT_CMD;
1622 res->data=ssiReadIntmat(d);
1623 break;
1624 case 19: res->rtyp=BIGINTMAT_CMD;
1625 res->data=ssiReadBigintmat(d);
1626 break;
1627 case 20: ssiReadBlackbox(res,l);
1628 break;
1629 case 21: ssiReadAttrib(res,l);
1630 break;
1631 case 23: ssiReadRingProperties(l);
1632 return ssiRead1(l);
1633 break;
1634 case 24: res->rtyp=BIGINTVEC_CMD;
1635 res->data=ssiReadBigintvec(d);
1636 break;
1637 // ------------
1638 case 98: // version
1639 {
1640 int n98_v,n98_m;
1642 n98_v=s_readint(d->f_read);
1643 n98_m=s_readint(d->f_read);
1644 n98_o1=s_readint(d->f_read);
1645 n98_o2=s_readint(d->f_read);
1646 if ((n98_v!=SSI_VERSION) ||(n98_m!=MAX_TOK))
1647 {
1648 Print("incompatible versions of ssi: %d/%d vs %d/%d\n",
1650 }
1651 #ifndef SING_NDEBUG
1652 if (TEST_OPT_DEBUG)
1653 Print("// opening ssi-%d, MAX_TOK=%d\n",n98_v,n98_m);
1654 #endif
1658 return ssiRead1(l);
1659 }
1660 case 99: omFreeBin(res,sleftv_bin); ssiClose(l); m2_end(0);
1661 break; /*to make compiler happy*/
1662 case 0: if (s_iseof(d->f_read))
1663 {
1664 ssiClose(l);
1665 }
1666 res->rtyp=DEF_CMD;
1667 break;
1668 default: Werror("not implemented (t:%d)",t);
1670 res=NULL;
1671 break;
1672 }
1673 // if currRing is required for the result, but lost
1674 // define "ssiRing%d" as currRing:
1675 if ((d->r!=NULL)
1676 && (currRing!=d->r)
1677 && (res->RingDependend()))
1678 {
1679 if(ssiSetCurrRing(d->r)) { d->r=currRing; }
1680 }
1681 return res;
1682no_ring: WerrorS("no ring");
1684 return NULL;
1685}
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:108
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 2194 of file ssiLink.cc.

2195{
2196 if (ssiReserved_P!=0)
2197 {
2198 WerrorS("ERROR already a reserved port requested");
2199 return 0;
2200 }
2201 int portno;
2203 if(ssiReserved_sockfd < 0)
2204 {
2205 WerrorS("ERROR opening socket");
2206 return 0;
2207 }
2208 memset((char *) &ssiResverd_serv_addr,0, sizeof(ssiResverd_serv_addr));
2209 portno = 1025;
2210 ssiResverd_serv_addr.sin_family = AF_INET;
2211 ssiResverd_serv_addr.sin_addr.s_addr = INADDR_ANY;
2212 do
2213 {
2214 portno++;
2215 ssiResverd_serv_addr.sin_port = htons(portno);
2216 if(portno > 50000)
2217 {
2218 WerrorS("ERROR on binding (no free port available?)");
2219 return 0;
2220 }
2221 }
2226 return portno;
2227}

◆ ssiWrite()

BOOLEAN ssiWrite ( si_link  l,
leftv  v 
)

Definition at line 1706 of file ssiLink.cc.

1707{
1708 if(SI_LINK_W_OPEN_P(l)==0)
1710 ssiInfo *d = (ssiInfo *)l->data;
1711 d->level++;
1712 //FILE *fich=d->f;
1713 while (data!=NULL)
1714 {
1715 int tt=data->Typ();
1716 void *dd=data->Data();
1717 attr *aa=data->Attribute();
1718 if ((aa!=NULL) && ((*aa)!=NULL)) // n user attributes
1719 {
1720 attr a=*aa;
1721 int n=0;
1722 while(a!=NULL) { n++; a=a->next;}
1723 fprintf(d->f_write,"21 %d %d ",data->flag,n);
1724 }
1725 else if (data->flag!=0) // only "flag" attributes
1726 {
1727 fprintf(d->f_write,"21 %d 0 ",data->flag);
1728 }
1729 if ((dd==NULL) && (data->name!=NULL) && (tt==0)) tt=DEF_CMD;
1730 // return pure undefined names as def
1731
1732 switch(tt /*data->Typ()*/)
1733 {
1734 case 0: /*error*/
1735 case NONE/* nothing*/:fputs("16 ",d->f_write);
1736 break;
1737 case STRING_CMD: fputs("2 ",d->f_write);
1738 ssiWriteString(d,(char *)dd);
1739 break;
1740 case INT_CMD: fputs("1 ",d->f_write);
1741 ssiWriteInt(d,(int)(long)dd);
1742 break;
1743 case BIGINT_CMD:fputs("4 ",d->f_write);
1745 break;
1746 case NUMBER_CMD:
1747 if (d->r!=currRing)
1748 {
1749 fputs("15 ",d->f_write);
1751 if (d->level<=1) fputc('\n',d->f_write);
1752 }
1753 fputs("3 ",d->f_write);
1755 break;
1756 case RING_CMD:fputs("5 ",d->f_write);
1757 ssiWriteRing(d,(ring)dd);
1758 break;
1759 case BUCKET_CMD:
1760 {
1762 if (d->r!=sBucketGetRing(b))
1763 {
1764 fputs("15 ",d->f_write);
1766 if (d->level<=1) fputc('\n',d->f_write);
1767 }
1768 fputs("6 ",d->f_write);
1770 break;
1771 }
1772 case POLY_CMD:
1773 case VECTOR_CMD:
1774 if (d->r!=currRing)
1775 {
1776 fputs("15 ",d->f_write);
1778 if (d->level<=1) fputc('\n',d->f_write);
1779 }
1780 if(tt==POLY_CMD) fputs("6 ",d->f_write);
1781 else fputs("9 ",d->f_write);
1782 ssiWritePoly(d,tt,(poly)dd);
1783 break;
1784 case IDEAL_CMD:
1785 case MODUL_CMD:
1786 case MATRIX_CMD:
1787 case SMATRIX_CMD:
1788 if (d->r!=currRing)
1789 {
1790 fputs("15 ",d->f_write);
1792 if (d->level<=1) fputc('\n',d->f_write);
1793 }
1794 if(tt==IDEAL_CMD) fputs("7 ",d->f_write);
1795 else if(tt==MATRIX_CMD) fputs("8 ",d->f_write);
1796 else if(tt==SMATRIX_CMD) fputs("22 ",d->f_write);
1797 else /* tt==MODUL_CMD*/
1798 {
1799 ideal M=(ideal)dd;
1800 fprintf(d->f_write,"10 %d ",(int)M->rank);
1801 }
1803 break;
1804 case COMMAND:
1805 fputs("11 ",d->f_write);
1807 break;
1808 case DEF_CMD: /* not evaluated stuff in quotes */
1809 fputs("12 ",d->f_write);
1810 ssiWriteString(d,data->Name());
1811 break;
1812 case PROC_CMD:
1813 fputs("13 ",d->f_write);
1815 break;
1816 case LIST_CMD:
1817 fputs("14 ",d->f_write);
1819 break;
1820 case INTVEC_CMD:
1821 fputs("17 ",d->f_write);
1822 ssiWriteIntvec(d,(intvec *)dd);
1823 break;
1824 case INTMAT_CMD:
1825 fputs("18 ",d->f_write);
1826 ssiWriteIntmat(d,(intvec *)dd);
1827 break;
1828 case BIGINTMAT_CMD:
1829 fputs("19 ",d->f_write);
1831 break;
1832 case BIGINTVEC_CMD:
1833 fputs("24 ",d->f_write);
1835 break;
1836 default:
1837 if (tt>MAX_TOK)
1838 {
1840 fputs("20 ",d->f_write);
1841 b->blackbox_serialize(b,dd,l);
1842 }
1843 else
1844 {
1845 Werror("not implemented (t:%d, rtyp:%d)",tt, data->rtyp);
1846 d->level=0;
1847 return TRUE;
1848 }
1849 break;
1850 }
1851 if (d->level<=1) { fputc('\n',d->f_write); fflush(d->f_write); }
1852 data=data->next;
1853 }
1854 d->level--;
1855 return FALSE;
1856}
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