int main(int argc, const char *argv[])
{
// char s[] = "mississippi";
char s[] = "aabaaaab";
int size = strlen(s);
printf("size = %d\n", size);
int *sa = NULL, *rank = NULL, *height = NULL;
get_sa(&s[0], size, &sa, &rank);
printf("---------End results----------------\n");
output(sa, size, "SA");
output(rank, size, "Rank");
output_suffix(sa, &s[0], size);
get_height(&s[0], sa, rank, size, &height);
output(height, size, "height");
if (sa) { free(sa); sa = NULL; }
if (rank) { free(rank); rank = NULL; }
if (height) { free(height); height = NULL; }
// calculate longest palindrome length
char palindrome_s[1024];
sprintf(palindrome_s, "%s#", s);
// reverse s
int begin = 0, end = size-1; char c;
while (begin < end) { c = s[begin]; s[begin++] = s[end]; s[end--] = c; }
strcat(palindrome_s, s);
size = strlen(palindrome_s);
get_sa(palindrome_s, size, &sa, &rank);
get_height(palindrome_s, sa, rank, size, &height);
output(height, size, "height");
output_suffix(sa, palindrome_s, size);
if (sa) { free(sa); sa = NULL; }
if (rank) { free(rank); rank = NULL; }
if (height) { free(height); height = NULL; }
return 0;
}
static bool parse_rxsci(int *argcp, char ***argvp, struct rxsc_desc *rxsc,
struct sa_desc *rxsa)
{
struct sci sci = { 0 };
if (*argcp == 0 ||
get_sci_portaddr(&sci, argcp, argvp, false, false) < 0) {
fprintf(stderr, "expected sci\n");
ipmacsec_usage();
}
rxsc->sci = sci.sci;
return get_sa(argcp, argvp, &rxsa->an);
}
static int do_modify_txsa(enum cmd c, int argc, char **argv, int ifindex)
{
struct sa_desc txsa = {0};
enum macsec_nl_commands cmd;
txsa.an = 0xff;
txsa.active = 0xff;
if (argc == 0 || !get_sa(&argc, &argv, &txsa.an))
ipmacsec_usage();
if (c == CMD_DEL)
goto modify;
if (parse_sa_args(&argc, &argv, &txsa))
return -1;
if (check_sa_args(c, &txsa))
return -1;
modify:
cmd = macsec_commands[c][1][0];
return do_modify_nl(c, cmd, ifindex, NULL, &txsa);
}
/*
* Notice:
* Before calling this function,
* precvframe->u.hdr.rx_data should be ready!
*/
void update_recvframe_phyinfo(
union recv_frame *precvframe,
struct phy_stat *pphy_status)
{
PADAPTER padapter= precvframe->u.hdr.adapter;
struct rx_pkt_attrib *pattrib = &precvframe->u.hdr.attrib;
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
PODM_PHY_INFO_T pPHYInfo = (PODM_PHY_INFO_T)(&pattrib->phy_info);
u8 *wlanhdr;
ODM_PACKET_INFO_T pkt_info;
u8 *sa;
//_irqL irqL;
struct sta_priv *pstapriv;
struct sta_info *psta;
pkt_info.bPacketMatchBSSID =_FALSE;
pkt_info.bPacketToSelf = _FALSE;
pkt_info.bPacketBeacon = _FALSE;
wlanhdr = get_recvframe_data(precvframe);
pkt_info.bPacketMatchBSSID = ((!IsFrameTypeCtrl(wlanhdr)) &&
!pattrib->icv_err && !pattrib->crc_err &&
_rtw_memcmp(get_hdr_bssid(wlanhdr), get_bssid(&padapter->mlmepriv), ETH_ALEN));
pkt_info.bPacketToSelf = pkt_info.bPacketMatchBSSID && (_rtw_memcmp(get_da(wlanhdr), myid(&padapter->eeprompriv), ETH_ALEN));
pkt_info.bPacketBeacon = pkt_info.bPacketMatchBSSID && (GetFrameSubType(wlanhdr) == WIFI_BEACON);
if(pkt_info.bPacketBeacon){
if(check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE) == _TRUE){
sa = padapter->mlmepriv.cur_network.network.MacAddress;
#if 0
{
DBG_8192C("==> rx beacon from AP[%02x:%02x:%02x:%02x:%02x:%02x]\n",
sa[0],sa[1],sa[2],sa[3],sa[4],sa[5]);
}
#endif
}
//to do Ad-hoc
}
else{
sa = get_sa(wlanhdr);
}
pkt_info.StationID = 0xFF;
pstapriv = &padapter->stapriv;
psta = rtw_get_stainfo(pstapriv, sa);
if (psta)
{
pkt_info.StationID = psta->mac_id;
//DBG_8192C("%s ==> StationID(%d)\n",__FUNCTION__,pkt_info.StationID);
}
pkt_info.Rate = pattrib->mcs_rate;
#ifdef CONFIG_CONCURRENT_MODE
//get Primary adapter's odmpriv
if(padapter->adapter_type > PRIMARY_ADAPTER){
pHalData = GET_HAL_DATA(padapter->pbuddy_adapter);
}
#endif
//rtl8192c_query_rx_phy_status(precvframe, pphy_status);
//_enter_critical_bh(&pHalData->odm_stainfo_lock, &irqL);
ODM_PhyStatusQuery(&pHalData->odmpriv,pPHYInfo,(u8 *)pphy_status,&(pkt_info));
//_exit_critical_bh(&pHalData->odm_stainfo_lock, &irqL);
precvframe->u.hdr.psta = NULL;
if (pkt_info.bPacketMatchBSSID &&
(check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == _TRUE))
{
if (psta)
{
precvframe->u.hdr.psta = psta;
rtl8192c_process_phy_info(padapter, precvframe);
}
}
else if (pkt_info.bPacketToSelf || pkt_info.bPacketBeacon)
{
if (check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE) == _TRUE)
{
if (psta)
{
precvframe->u.hdr.psta = psta;
}
}
rtl8192c_process_phy_info(padapter, precvframe);
}
}
int64_t
naive_lcp
(
int min_depth,
uint64_t idxsize,
uint64_t * lcpsample,
uint64_t * lcpext,
stack8_t ** lcp,
stack64_t ** ext,
uint64_t * sar,
int sar_bits,
char * genome
)
{
cstack_t * top = cstack_new(STACK_LCP_INITIAL_SIZE);
cstack_t * bottom = cstack_new(STACK_LCP_INITIAL_SIZE);
// Push topmost corner.
corner_push(&top, (lcpcorner_t){-1, 0, 0, 0});
if (min_depth == 0) {
lcp_index_set(lcpsample, 0);
if (stack_push_lcp(lcp, 0, -1)) return -1;
}
// Compute LCP of i=1, store in previous.
uint64_t cp = get_sa(0,sar,sar_bits);
int cl = 0;
uint64_t pp = get_sa(1,sar,sar_bits);
int pl = seq_lcp(genome+pp, genome+cp);
for (uint64_t i = 2; i < idxsize; i++) {
// Current position and lcp.
cp = get_sa(i,sar,sar_bits);
cl = seq_lcp(genome+pp, genome+cp);
// If current LCP > previous LCP -> Previous was top corner.
if (cl > pl) {
// Top corner - save sample.
lcpcorner_t tcorner = top->c[top->pos-1];
int64_t offset = tcorner.pos - (i-1);
if (cl >= min_depth) {
lcp_index_set(lcpsample, i-1);
if (stack_push_lcp(lcp, pl, offset)) return -1;
}
// Push corner to the stack.
corner_push(&top, (lcpcorner_t){pl, cl, i-1, 0});
}
// If current LCP < previous LCP -> Previous was bottom corner.
else if (cl < pl) {
// Bottom corner - save sample.
if (pl >= min_depth) {
if (stack_push_lcp(lcp, pl, 0xFFFFFFFF)) return -1;
}
while (bottom->pos > 0) {
if (bottom->c[bottom->pos-1].lcp_next <= cl) break;
// Pop sample from bottom stack and save.
lcpcorner_t bcorner = corner_pop(bottom);
// Bottom corner - update sample.
if (bcorner.lcp >= min_depth) {
int64_t offset = i-1 - bcorner.pos;
memcpy((*lcp)->val + bcorner.ptr, &offset, sizeof(int64_t));
lcp_index_set(lcpsample, bcorner.pos);
}
}
// Save current bottom corner.
corner_push(&bottom, (lcpcorner_t){pl, cl, i-1, (*lcp)->pos - sizeof(int64_t)});
// Remove top corners from stack.
while (top->pos > 0) {
if (top->c[top->pos-1].lcp < cl) break;
top->pos--;
}
}
// Assign previous.
pp = cp;
pl = cl;
}
// Add remaining bottom nodes.
while (bottom->pos > 0) {
// Pop sample from bottom stack and save.
lcpcorner_t bcorner = corner_pop(bottom);
// Bottom corner - update sample.
if (bcorner.lcp >= min_depth) {
int offset = idxsize-1 - bcorner.pos;
memcpy((*lcp)->val + bcorner.ptr, &offset, sizeof(int64_t));
lcp_index_set(lcpsample, bcorner.pos);
}
}
if (min_depth == 0) {
lcp_index_set(lcpsample, idxsize-1);
if (stack_push_lcp(lcp, pl, 0)) return -1;
}
free(top);
free(bottom);
// Compact LCP.
stack8_t * stack = *lcp;
int64_t val = 0;
uint64_t p = 0, i = 0;
while (i < stack->pos) {
// Save LCP value.
stack->val[p++] = stack->val[i++];
// Compress offset.
memcpy(&val, stack->val + i, sizeof(int64_t));
if (val < -127) {
lcp_index_set(lcpext,p/2);
stack->val[p++] = (int8_t)-128;
stack64_push(ext, val);
} else if (val > 127) {
lcp_index_set(lcpext,p/2);
stack->val[p++] = (int8_t)127;
stack64_push(ext, val);
} else {
stack->val[p++] = (int8_t)val - (val > 0);
}
i += sizeof(int64_t);
}
stack->pos = p;
*lcp = realloc(*lcp, sizeof(stack8_t) + stack->pos*sizeof(int8_t));
if (*lcp == NULL) return -1;
(*lcp)->size = p;
*ext = realloc(*ext, sizeof(stack64_t) + (*ext)->pos*sizeof(int64_t));
if (*ext == NULL) return -1;
(*ext)->size = (*ext)->pos;
return 0;
}
