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

2317{
2318 pid_t kidpid;
2319 int status;
2320
2321 loop
2322 {
2324 if (kidpid==-1)
2325 {
2326 /* continue on interruption (EINTR): */
2327 if (errno == EINTR) continue;
2328 /* break on anything else (EINVAL or ECHILD according to manpage): */
2329 break;
2330 }
2331 else if (kidpid==0) break; /* no more children to process, so break */
2332
2333 //printf("Child %ld terminated\n", kidpid);
2335 while((hh!=NULL)&&(ssiToBeClosed_inactive))
2336 {
2337 if((hh->l!=NULL) && (hh->l->m->Open==ssiOpen))
2338 {
2339 ssiInfo *d = (ssiInfo *)hh->l->data;
2340 if(d->pid==kidpid)
2341 {
2343 {
2345 slClose(hh->l);
2347 break;
2348 }
2349 else break;
2350 }
2351 else hh=(link_list)hh->next;
2352 }
2353 else hh=(link_list)hh->next;
2354 }
2355 }
2356}
#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 1876 of file ssiLink.cc.

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

◆ slStatusSsi()

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

Definition at line 1893 of file ssiLink.cc.

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

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

2246{
2247 if (ssiReserved_P==0)
2248 {
2249 WerrorS("ERROR no reserved port requested");
2250 return NULL;
2251 }
2252 struct sockaddr_in cli_addr;
2253 int clilen = sizeof(cli_addr);
2255 if(newsockfd < 0)
2256 {
2257 Werror("ERROR on accept (errno=%d)",errno);
2258 return NULL;
2259 }
2262 si_link_extension prev = s;
2263 while (strcmp(s->type, "ssi") != 0)
2264 {
2265 if (s->next == NULL)
2266 {
2267 prev = s;
2268 s = NULL;
2269 break;
2270 }
2271 else
2272 {
2273 s = s->next;
2274 }
2275 }
2276 if (s != NULL)
2277 l->m = s;
2278 else
2279 {
2281 prev->next=slInitSsiExtension(ns);
2282 l->m = prev->next;
2283 }
2284 l->name=omStrDup("");
2285 l->mode=omStrDup("tcp");
2286 l->ref=1;
2287 ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
2288 l->data=d;
2289 d->fd_read = newsockfd;
2290 d->fd_write = newsockfd;
2291 d->f_read = s_open(newsockfd);
2292 d->f_write = fdopen(newsockfd, "w");
2295 if (ssiReserved_Clients<=0)
2296 {
2297 ssiReserved_P=0;
2299 }
2300 return l;
2301}
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 996 of file ssiLink.cc.

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

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

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

◆ ssiWrite()

BOOLEAN ssiWrite ( si_link  l,
leftv  v 
)

Definition at line 1719 of file ssiLink.cc.

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